Schoumi/BLE_API
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Merge branch 'gattClient' into develop

Browse source
This commit is contained in:
Rohit Grover 2015-06-16 11:17:54 +01:00
commit 532535b1ec
20 changed files with 854 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
common/BLEDeviceInstanceBase.h
View file

@ -17,6 +17,12 @@
#ifndef __BLE_DEVICE_INSTANCE_BASE__
#define __BLE_DEVICE_INSTANCE_BASE__
#include "Gap.h"
/* forward declarations */
class GattServer;
class GattClient;
/**
* The interface for the transport object to be created by the target library's
* createBLEDeviceInstance().
@ -30,6 +36,7 @@ public:
virtual const char *getVersion(void) = 0;
virtual Gap& getGap() = 0;
virtual GattServer& getGattServer() = 0;
virtual GattClient& getGattClient() = 0;
virtual ble_error_t initializeSecurity(bool enableBonding = true,
bool requireMITM = true,
Gap::SecurityIOCapabilities_t iocaps = Gap::IO_CAPS_NONE,

63
common/DiscoveredCharacteristic.cpp Normal file
View file

@ -0,0 +1,63 @@
/* mbed Microcontroller Library
* Copyright (c) 2006-2013 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "DiscoveredCharacteristic.h"
#include "GattClient.h"
GattClient::ReadCallback_t DiscoveredCharacteristic::onDataReadCallback;
GattClient::WriteCallback_t DiscoveredCharacteristic::onDataWriteCallback;
ble_error_t
DiscoveredCharacteristic::read(uint16_t offset) const
{
if (!props.read()) {
return BLE_ERROR_OPERATION_NOT_PERMITTED;
}
if (!gattc) {
return BLE_ERROR_INVALID_STATE;
}
return gattc->read(connHandle, valueHandle, offset);
}
ble_error_t
DiscoveredCharacteristic::write(uint16_t length, const uint8_t *value) const
{
if (!props.write()) {
return BLE_ERROR_OPERATION_NOT_PERMITTED;
}
if (!gattc) {
return BLE_ERROR_INVALID_STATE;
}
return gattc->write(GattClient::GATT_OP_WRITE_REQ, connHandle, valueHandle, length, value);
}
ble_error_t
DiscoveredCharacteristic::writeWoResponse(uint16_t length, const uint8_t *value) const
{
if (!props.writeWoResp()) {
return BLE_ERROR_OPERATION_NOT_PERMITTED;
}
if (!gattc) {
return BLE_ERROR_INVALID_STATE;
}
return gattc->write(GattClient::GATT_OP_WRITE_CMD, connHandle, valueHandle, length, value);
}

26
common/blecommon.h
View file

@ -21,8 +21,6 @@
extern "C" {
#endif
#include <stdint.h>
#include <stddef.h>
/** @defgroup BLE_UUID_VALUES Assigned Values for BLE UUIDs
* @{ */
@ -115,18 +113,18 @@ enum {
\brief Error codes for the BLE API
*/
/**************************************************************************/
typedef enum ble_error_e
{
BLE_ERROR_NONE = 0, /**< No error */
BLE_ERROR_BUFFER_OVERFLOW = 1, /**< The requested action would cause a buffer overflow and has been aborted */
BLE_ERROR_NOT_IMPLEMENTED = 2, /**< Requested a feature that isn't yet implement or isn't supported by the target HW */
BLE_ERROR_PARAM_OUT_OF_RANGE = 3, /**< One of the supplied parameters is outside the valid range */
BLE_ERROR_INVALID_PARAM = 4, /**< One of the supplied parameters is invalid */
BLE_STACK_BUSY = 5, /**< The stack is busy */
BLE_ERROR_INVALID_STATE = 6, /**< Invalid state. */
BLE_ERROR_NO_MEM = 7, /**< Out of Memory */
BLE_ERROR_UNSPECIFIED = 8, /**< Unknown error. */
} ble_error_t;
enum ble_error_t {
BLE_ERROR_NONE = 0, /**< No error */
BLE_ERROR_BUFFER_OVERFLOW = 1, /**< The requested action would cause a buffer overflow and has been aborted */
BLE_ERROR_NOT_IMPLEMENTED = 2, /**< Requested a feature that isn't yet implement or isn't supported by the target HW */
BLE_ERROR_PARAM_OUT_OF_RANGE = 3, /**< One of the supplied parameters is outside the valid range */
BLE_ERROR_INVALID_PARAM = 4, /**< One of the supplied parameters is invalid */
BLE_STACK_BUSY = 5, /**< The stack is busy */
BLE_ERROR_INVALID_STATE = 6, /**< Invalid state. */
BLE_ERROR_NO_MEM = 7, /**< Out of Memory */
BLE_ERROR_OPERATION_NOT_PERMITTED = 8,
BLE_ERROR_UNSPECIFIED = 9, /**< Unknown error. */
};
#ifdef __cplusplus
}

175
public/BLEDevice.h
View file

@ -20,9 +20,14 @@
#include "blecommon.h"
#include "Gap.h"
#include "GattServer.h"
#include "GapScanningParams.h"
#include "GattClient.h"
#include "BLEDeviceInstanceBase.h"
#include "GapAdvertisingData.h"
#include "GapAdvertisingParams.h"
#include "GapScanningParams.h"
/**
* The base class used to abstract away BLE capable radio transceivers or SOCs,
* to enable this BLE API to work with any radio transparently.
@ -315,6 +320,25 @@ public:
*/
ble_error_t stopScan(void);
/**
* Create a connection (GAP Link Establishment).
* @param peerAddr
* 48-bit address, LSB format.
* @param peerAddrType
* Address type of the peer.
* @param connectionParams
* Connection parameters.
* @param scanParams
* Paramters to be used while scanning for the peer.
* @return BLE_ERROR_NONE if connection establishment procedure is started
* successfully. The onConnection callback (if set) will be invoked upon
* a connection event.
*/
ble_error_t connect(const Gap::Address_t peerAddr,
Gap::AddressType_t peerAddrType = Gap::ADDR_TYPE_RANDOM_STATIC,
const Gap::ConnectionParams_t *connectionParams = NULL,
const GapScanningParams *scanParams = NULL);
/**
* This call initiates the disconnection procedure, and its completion will
* be communicated to the application with an invocation of the
@ -368,8 +392,8 @@ public:
* @Note: it is also possible to setup a callback into a member function of
* some object.
*/
void onDataWritten(void (*callback)(const GattCharacteristicWriteCBParams *eventDataP));
template <typename T> void onDataWritten(T * objPtr, void (T::*memberPtr)(const GattCharacteristicWriteCBParams *context));
void onDataWritten(void (*callback)(const GattWriteCallbackParams *eventDataP));
template <typename T> void onDataWritten(T * objPtr, void (T::*memberPtr)(const GattWriteCallbackParams *context));
/**
* Setup a callback for when a characteristic is being read by a client.
@ -389,8 +413,8 @@ public:
* @return BLE_ERROR_NOT_IMPLEMENTED if this functionality isn't available;
* else BLE_ERROR_NONE.
*/
ble_error_t onDataRead(void (*callback)(const GattCharacteristicReadCBParams *eventDataP));
template <typename T> ble_error_t onDataRead(T * objPtr, void (T::*memberPtr)(const GattCharacteristicReadCBParams *context));
ble_error_t onDataRead(void (*callback)(const GattReadCallbackParams *eventDataP));
template <typename T> ble_error_t onDataRead(T * objPtr, void (T::*memberPtr)(const GattReadCallbackParams *context));
void onUpdatesEnabled(GattServer::EventCallback_t callback);
void onUpdatesDisabled(GattServer::EventCallback_t callback);
@ -445,7 +469,11 @@ public:
/**
* A version of the same as above with connection handle parameter to allow updates for connection-specific multivalued attribtues (such as the CCCDs).
*/
ble_error_t updateCharacteristicValue(Gap::Handle_t connectionHandle, GattAttribute::Handle_t attributeHandle, const uint8_t *value, uint16_t size, bool localOnly = false);
ble_error_t updateCharacteristicValue(Gap::Handle_t connectionHandle,
GattAttribute::Handle_t attributeHandle,
const uint8_t *value,
uint16_t size,
bool localOnly = false);
/**
* Yield control to the BLE stack or to other tasks waiting for events. This
@ -611,6 +639,78 @@ public:
*/
ble_error_t purgeAllBondingState(void);
/**
* Launch service discovery. Once launched, service discovery will remain
* active with callbacks being issued back into the application for matching
* services/characteristics. isServiceDiscoveryActive() can be used to
* determine status; and a termination callback (if setup) will be invoked
* at the end. Service discovery can be terminated prematurely if needed
* using terminateServiceDiscovery().
*
* @param connectionHandle
* Handle for the connection with the peer.
* @param sc
* This is the application callback for matching service. Taken as
* NULL by default. Note: service discovery may still be active
* when this callback is issued; calling asynchronous BLE-stack
* APIs from within this application callback might cause the
* stack to abort service discovery. If this becomes an issue, it
* may be better to make local copy of the discoveredService and
* wait for service discovery to terminate before operating on the
* service.
* @param cc
* This is the application callback for matching characteristic.
* Taken as NULL by default. Note: service discovery may still be
* active when this callback is issued; calling asynchronous
* BLE-stack APIs from within this application callback might cause
* the stack to abort service discovery. If this becomes an issue,
* it may be better to make local copy of the discoveredCharacteristic
* and wait for service discovery to terminate before operating on the
* characteristic.
* @param matchingServiceUUID
* UUID based filter for specifying a service in which the application is
* interested. By default it is set as the wildcard UUID_UNKNOWN,
* in which case it matches all services. If characteristic-UUID
* filter (below) is set to the wildcard value, then a service
* callback will be invoked for the matching service (or for every
* service if the service filter is a wildcard).
* @param matchingCharacteristicUUIDIn
* UUID based filter for specifying characteristic in which the application
* is interested. By default it is set as the wildcard UUID_UKNOWN
* to match against any characteristic. If both service-UUID
* filter and characteristic-UUID filter are used with non- wildcard
* values, then only a single characteristic callback is
* invoked for the matching characteristic.
*
* @Note Using wildcard values for both service-UUID and characteristic-
* UUID will result in complete service discovery--callbacks being
* called for every service and characteristic.
*
* @return
* BLE_ERROR_NONE if service discovery is launched successfully; else an appropriate error.
*/
ble_error_t launchServiceDiscovery(Gap::Handle_t connectionHandle,
ServiceDiscovery::ServiceCallback_t sc = NULL,
ServiceDiscovery::CharacteristicCallback_t cc = NULL,
const UUID &matchingServiceUUID = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN),
const UUID &matchingCharacteristicUUIDIn = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN));
/**
* Setup callback for when serviceDiscovery terminates.
*/
void onServiceDiscoveryTermination(ServiceDiscovery::TerminationCallback_t callback);
/**
* Is service-discovery currently active?
*/
bool isServiceDiscoveryActive(void);
/**
* Terminate an ongoing service-discovery. This should result in an
* invocation of the TerminationCallback if service-discovery is active.
*/
void terminateServiceDiscovery(void);
public:
BLE() : transport(createBLEDeviceInstance()), advParams(), advPayload(), scanResponse(), needToSetAdvPayload(true), scanningParams() {
advPayload.clear();
@ -856,6 +956,14 @@ BLE::stopScan(void) {
return transport->getGap().stopScan();
}
inline ble_error_t
BLEDevice::connect(const Gap::Address_t peerAddr,
Gap::AddressType_t peerAddrType,
const Gap::ConnectionParams_t *connectionParams,
const GapScanningParams *scanParams) {
return transport->getGap().connect(peerAddr, peerAddrType, connectionParams, scanParams);
}
inline ble_error_t
BLE::disconnect(Gap::DisconnectionReason_t reason)
{
@ -897,22 +1005,22 @@ BLE::onDataSent(T *objPtr, void (T::*memberPtr)(unsigned count)) {
}
inline void
BLE::onDataWritten(void (*callback)(const GattCharacteristicWriteCBParams *eventDataP)) {
BLE::onDataWritten(void (*callback)(const GattWriteCallbackParams *eventDataP)) {
transport->getGattServer().setOnDataWritten(callback);
}
template <typename T> inline void
BLE::onDataWritten(T *objPtr, void (T::*memberPtr)(const GattCharacteristicWriteCBParams *context)) {
BLE::onDataWritten(T *objPtr, void (T::*memberPtr)(const GattWriteCallbackParams *context)) {
transport->getGattServer().setOnDataWritten(objPtr, memberPtr);
}
inline ble_error_t
BLE::onDataRead(void (*callback)(const GattCharacteristicReadCBParams *eventDataP)) {
BLE::onDataRead(void (*callback)(const GattReadCallbackParams *eventDataP)) {
return transport->getGattServer().setOnDataRead(callback);
}
template <typename T> inline ble_error_t
BLE::onDataRead(T *objPtr, void (T::*memberPtr)(const GattCharacteristicReadCBParams *context)) {
BLE::onDataRead(T *objPtr, void (T::*memberPtr)(const GattReadCallbackParams *context)) {
return transport->getGattServer().setOnDataRead(objPtr, memberPtr);
}
@ -959,7 +1067,10 @@ BLE::readCharacteristicValue(GattAttribute::Handle_t attributeHandle, uint8_t *b
}
inline ble_error_t
BLE::readCharacteristicValue(Gap::Handle_t connectionHandle, GattAttribute::Handle_t attributeHandle, uint8_t *buffer, uint16_t *lengthP)
BLE::readCharacteristicValue(Gap::Handle_t connectionHandle,
GattAttribute::Handle_t attributeHandle,
uint8_t *buffer,
uint16_t *lengthP)
{
return transport->getGattServer().readValue(connectionHandle, attributeHandle, buffer, lengthP);
}
@ -971,7 +1082,11 @@ BLE::updateCharacteristicValue(GattAttribute::Handle_t attributeHandle, const ui
}
inline ble_error_t
BLE::updateCharacteristicValue(Gap::Handle_t connectionHandle, GattAttribute::Handle_t attributeHandle, const uint8_t *value, uint16_t size, bool localOnly)
BLE::updateCharacteristicValue(Gap::Handle_t connectionHandle,
GattAttribute::Handle_t attributeHandle,
const uint8_t *value,
uint16_t size,
bool localOnly)
{
return transport->getGattServer().updateValue(connectionHandle, attributeHandle, const_cast<uint8_t *>(value), size, localOnly);
}
@ -1092,4 +1207,40 @@ BLE::purgeAllBondingState(void)
return transport->getGap().purgeAllBondingState();
}
inline ble_error_t
BLEDevice::launchServiceDiscovery(Gap::Handle_t connectionHandle,
ServiceDiscovery::ServiceCallback_t sc,
ServiceDiscovery::CharacteristicCallback_t cc,
const UUID &matchingServiceUUID,
const UUID &matchingCharacteristicUUID)
{
return transport->getGattClient().launchServiceDiscovery(connectionHandle, sc, cc, matchingServiceUUID, matchingCharacteristicUUID);
}
inline void
BLEDevice::onServiceDiscoveryTermination(ServiceDiscovery::TerminationCallback_t callback)
{
transport->getGattClient().onServiceDiscoveryTermination(callback);
}
/**
* Is service-discovery currently active?
*/
inline bool
BLEDevice::isServiceDiscoveryActive(void)
{
return transport->getGattClient().isServiceDiscoveryActive();
}
/**
* Terminate an ongoing service-discovery. This should result in an
* invocation of the TerminationCallback if service-discovery is active.
*/
inline void
BLEDevice::terminateServiceDiscovery(void)
{
transport->getGattClient().terminateServiceDiscovery();
}
#endif // ifndef __BLE_DEVICE__

161
public/DiscoveredCharacteristic.h Normal file
View file

@ -0,0 +1,161 @@
/* mbed Microcontroller Library
* Copyright (c) 2006-2013 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __DISCOVERED_CHARACTERISTIC_H__
#define __DISCOVERED_CHARACTERISTIC_H__
#include "UUID.h"
#include "Gap.h"
#include "GattAttribute.h"
#include "GattClient.h"
/**
* Structure for holding information about the service and the characteristics
* found during the discovery process.
*/
class DiscoveredCharacteristic {
public:
struct Properties_t {
uint8_t _broadcast :1; /**< Broadcasting of the value permitted. */
uint8_t _read :1; /**< Reading the value permitted. */
uint8_t _writeWoResp :1; /**< Writing the value with Write Command permitted. */
uint8_t _write :1; /**< Writing the value with Write Request permitted. */
uint8_t _notify :1; /**< Notications of the value permitted. */
uint8_t _indicate :1; /**< Indications of the value permitted. */
uint8_t _authSignedWrite :1; /**< Writing the value with Signed Write Command permitted. */
public:
bool broadcast(void) const {return _broadcast; }
bool read(void) const {return _read; }
bool writeWoResp(void) const {return _writeWoResp; }
bool write(void) const {return _write; }
bool notify(void) const {return _notify; }
bool indicate(void) const {return _indicate; }
bool authSignedWrite(void) const {return _authSignedWrite;}
private:
operator uint8_t() const; /* disallow implicit conversion into an integer */
operator unsigned() const; /* disallow implicit conversion into an integer */
};
/**
* Initiate (or continue) a read for the value attribute, optionally at a
* given offset. If the Characteristic or Descriptor to be read is longer
* than ATT_MTU - 1, this function must be called multiple times with
* appropriate offset to read the complete value.
*
* @return BLE_ERROR_NONE if a read has been initiated, else
* BLE_ERROR_INVALID_STATE if some internal state about the connection is invalid, or
* BLE_STACK_BUSY if some client procedure already in progress, or
* BLE_ERROR_OPERATION_NOT_PERMITTED due to the characteristic's properties.
*/
ble_error_t read(uint16_t offset = 0) const;
/**
* Perform a write without response procedure.
*
* @param length
* The amount of data being written.
* @param value
* The bytes being written.
*
* @note It is important to note that a write without response will generate
* an onDataSent() callback when the packet has been transmitted. There
* will be a BLE-stack specific limit to the number of pending
* writeWoResponse operations; the user may want to use the onDataSent()
* callback for flow-control.
*
* @retval BLE_ERROR_NONE Successfully started the Write procedure, else
* BLE_ERROR_INVALID_STATE if some internal state about the connection is invalid, or
* BLE_STACK_BUSY if some client procedure already in progress, or
* BLE_ERROR_NO_MEM if there are no available buffers left to process the request, or
* BLE_ERROR_OPERATION_NOT_PERMITTED due to the characteristic's properties.
*/
ble_error_t writeWoResponse(uint16_t length, const uint8_t *value) const;
/**
* Perform a write procedure.
*
* @param length
* The amount of data being written.
* @param value
* The bytes being written.
*
* @note It is important to note that a write will generate
* an onDataWritten() callback when the peer acknowledges the request.
*
* @retval BLE_ERROR_NONE Successfully started the Write procedure, else
* BLE_ERROR_INVALID_STATE if some internal state about the connection is invalid, or
* BLE_STACK_BUSY if some client procedure already in progress, or
* BLE_ERROR_NO_MEM if there are no available buffers left to process the request, or
* BLE_ERROR_OPERATION_NOT_PERMITTED due to the characteristic's properties.
*/
ble_error_t write(uint16_t length, const uint8_t *value) const;
static void setupOnDataRead(GattClient::ReadCallback_t callback) {
onDataReadCallback = callback;
}
static void setupOnDataWrite(GattClient::WriteCallback_t callback) {
onDataWriteCallback = callback;
}
void setupLongUUID(UUID::LongUUIDBytes_t longUUID) {
uuid.setupLong(longUUID);
}
public:
UUID::ShortUUIDBytes_t getShortUUID(void) const {
return uuid.getShortUUID();
}
const Properties_t& getProperties(void) const {
return props;
}
const GattAttribute::Handle_t& getDeclHandle(void) const {
return declHandle;
}
const GattAttribute::Handle_t& getValueHandle(void) const {
return valueHandle;
}
public:
DiscoveredCharacteristic() : gattc(NULL),
uuid(UUID::ShortUUIDBytes_t(0)),
props(),
declHandle(GattAttribute::INVALID_HANDLE),
valueHandle(GattAttribute::INVALID_HANDLE) {
/* empty */
}
protected:
GattClient *gattc;
protected:
UUID uuid;
Properties_t props;
GattAttribute::Handle_t declHandle;
GattAttribute::Handle_t valueHandle;
Gap::Handle_t connHandle;
public:
static GattClient::ReadCallback_t onDataReadCallback;
static GattClient::WriteCallback_t onDataWriteCallback;
};
#endif /*__DISCOVERED_CHARACTERISTIC_H__*/

71
public/DiscoveredService.h Normal file
View file

@ -0,0 +1,71 @@
/* mbed Microcontroller Library
* Copyright (c) 2006-2013 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __DISCOVERED_SERVICE_H__
#define __DISCOVERED_SERVICE_H__
#include "UUID.h"
#include "GattAttribute.h"
/**@brief Type for holding information about the service and the characteristics found during
* the discovery process.
*/
class DiscoveredService {
public:
void setup(UUID uuidIn, GattAttribute::Handle_t startHandleIn, GattAttribute::Handle_t endHandleIn) {
uuid = uuidIn;
startHandle = startHandleIn;
endHandle = endHandleIn;
}
void setup(GattAttribute::Handle_t startHandleIn, GattAttribute::Handle_t endHandleIn) {
startHandle = startHandleIn;
endHandle = endHandleIn;
}
void setupLongUUID(UUID::LongUUIDBytes_t longUUID) {
uuid.setupLong(longUUID);
}
public:
const UUID &getUUID(void) const {
return uuid;
}
const GattAttribute::Handle_t& getStartHandle(void) const {
return startHandle;
}
const GattAttribute::Handle_t& getEndHandle(void) const {
return endHandle;
}
public:
DiscoveredService() : uuid(UUID::ShortUUIDBytes_t(0)),
startHandle(GattAttribute::INVALID_HANDLE),
endHandle(GattAttribute::INVALID_HANDLE) {
/* empty */
}
private:
DiscoveredService(const DiscoveredService &);
private:
UUID uuid; /**< UUID of the service. */
GattAttribute::Handle_t startHandle; /**< Service Handle Range. */
GattAttribute::Handle_t endHandle; /**< Service Handle Range. */
};
#endif /*__DISCOVERED_SERVICE_H__*/

84
public/Gap.h
View file

@ -17,15 +17,16 @@
#ifndef __GAP_H__
#define __GAP_H__
#include "GapAdvertisingData.h"
#include "GapAdvertisingParams.h"
#include "GapEvents.h"
#include "CallChain.h"
#include "FunctionPointerWithContext.h"
using namespace mbed;
class GapScanningParams; /* forward declaration */
/* Forward declarations for classes which will only be used for pointers or references in the following. */
class GapAdvertisingParams;
class GapScanningParams;
class GapAdvertisingData;
class Gap {
public:
@ -79,6 +80,49 @@ public:
uint16_t connectionSupervisionTimeout; /**< Connection Supervision Timeout in 10 ms units, see @ref BLE_GAP_CP_LIMITS.*/
} ConnectionParams_t;
enum Role_t {
PERIPHERAL = 0x1, /**< Peripheral Role. */
CENTRAL = 0x2, /**< Central Role. */
};
struct AdvertisementCallbackParams_t {
Address_t peerAddr;
int8_t rssi;
bool isScanResponse;
AdvertisementType_t type;
uint8_t advertisingDataLen;
const uint8_t *advertisingData;
};
typedef FunctionPointerWithContext<const AdvertisementCallbackParams_t *> AdvertisementReportCallback_t;
struct ConnectionCallbackParams_t {
Handle_t handle;
Role_t role;
AddressType_t peerAddrType;
Address_t peerAddr;
AddressType_t ownAddrType;
Address_t ownAddr;
const ConnectionParams_t *connectionParams;
ConnectionCallbackParams_t(Handle_t handleIn,
Role_t roleIn,
AddressType_t peerAddrTypeIn,
const uint8_t *peerAddrIn,
AddressType_t ownAddrTypeIn,
const uint8_t *ownAddrIn,
const ConnectionParams_t *connectionParamsIn) :
handle(handleIn),
role(roleIn),
peerAddrType(peerAddrTypeIn),
peerAddr(),
ownAddrType(ownAddrTypeIn),
ownAddr(),
connectionParams(connectionParamsIn) {
memcpy(peerAddr, peerAddrIn, ADDR_LEN);
memcpy(ownAddr, ownAddrIn, ADDR_LEN);
}
};
enum SecurityMode_t {
SECURITY_MODE_NO_ACCESS,
SECURITY_MODE_ENCRYPTION_OPEN_LINK, /**< require no protection, open link. */
@ -144,10 +188,7 @@ public:
}
typedef void (*EventCallback_t)(void);
typedef void (*ConnectionEventCallback_t)(Handle_t,
AddressType_t peerAddrType, const Address_t peerAddr,
AddressType_t ownAddrType, const Address_t ownAddr,
const ConnectionParams_t *);
typedef void (*ConnectionEventCallback_t)(const ConnectionCallbackParams_t *params);
typedef void (*HandleSpecificEvent_t)(Handle_t handle);
typedef void (*DisconnectionEventCallback_t)(Handle_t, DisconnectionReason_t);
typedef void (*RadioNotificationEventCallback_t) (bool radio_active); /* gets passed true for ACTIVE; false for INACTIVE. */
@ -156,20 +197,10 @@ public:
typedef void (*LinkSecuredCallback_t)(Handle_t handle, SecurityMode_t securityMode);
typedef void (*PasskeyDisplayCallback_t)(Handle_t handle, const Passkey_t passkey);
struct AdvertisementCallbackParams_t {
Address_t peerAddr;
int8_t rssi;
bool isScanResponse;
AdvertisementType_t type;
uint8_t advertisingDataLen;
const uint8_t *advertisingData;
};
typedef FunctionPointerWithContext<const AdvertisementCallbackParams_t *> AdvertisementReportCallback_t;
public:
/* These functions must be defined in the sub-class */
virtual ble_error_t setAddress(AddressType_t type, const Address_t address) = 0;
virtual ble_error_t getAddress(AddressType_t *typeP, Address_t address) = 0;
virtual ble_error_t setAddress(AddressType_t type, const Address_t address) = 0;
virtual ble_error_t getAddress(AddressType_t *typeP, Address_t address) = 0;
virtual ble_error_t setAdvertisingData(const GapAdvertisingData &, const GapAdvertisingData &) = 0;
virtual ble_error_t startAdvertising(const GapAdvertisingParams &) = 0;
virtual ble_error_t stopAdvertising(void) = 0;
@ -177,6 +208,10 @@ public:
virtual uint16_t getMinAdvertisingInterval(void) const = 0;
virtual uint16_t getMinNonConnectableAdvertisingInterval(void) const = 0;
virtual uint16_t getMaxAdvertisingInterval(void) const = 0;
virtual ble_error_t connect(const Address_t peerAddr,
Gap::AddressType_t peerAddrType,
const ConnectionParams_t *connectionParams,
const GapScanningParams *scanParams) = 0;
virtual ble_error_t disconnect(DisconnectionReason_t reason) = 0;
virtual ble_error_t getPreferredConnectionParams(ConnectionParams_t *params) = 0;
virtual ble_error_t setPreferredConnectionParams(const ConnectionParams_t *params) = 0;
@ -303,10 +338,17 @@ protected:
}
public:
void processConnectionEvent(Handle_t handle, AddressType_t peerAddrType, const Address_t peerAddr, AddressType_t ownAddrType, const Address_t ownAddr, const ConnectionParams_t *params) {
void processConnectionEvent(Handle_t handle,
Role_t role,
AddressType_t peerAddrType,
const Address_t peerAddr,
AddressType_t ownAddrType,
const Address_t ownAddr,
const ConnectionParams_t *connectionParams) {
state.connected = 1;
if (onConnection) {
onConnection(handle, peerAddrType, peerAddr, ownAddrType, ownAddr, params);
ConnectionCallbackParams_t callbackParams(handle, role, peerAddrType, peerAddr, ownAddrType, ownAddr, connectionParams);
onConnection(&callbackParams);
}
}

2
public/GapScanningParams.h
View file

@ -80,7 +80,7 @@ public:
_activeScanning = activeScanning;
}
public:
/* @Note: The following return durations in units of 0.625 ms */
uint16_t getInterval(void) const {return _interval;}
uint16_t getWindow(void) const {return _window; }

2
public/GattAttribute.h
View file

@ -17,6 +17,8 @@
#ifndef __GATT_ATTRIBUTE_H__
#define __GATT_ATTRIBUTE_H__
#include "UUID.h"
class GattAttribute {
public:
typedef uint16_t Handle_t;

68
public/GattCharacteristicCallbackParams.h → public/GattCallbackParamTypes.h
View file

@ -14,37 +14,35 @@
* limitations under the License.
*/
#ifndef __GATT_CHARACTERISTIC_CALLBACK_PARAMS_H__
#define __GATT_CHARACTERISTIC_CALLBACK_PARAMS_H__
#ifndef __GATT_CALLBACK_PARAM_TYPES_H__
#define __GATT_CALLBACK_PARAM_TYPES_H__
struct GattCharacteristicWriteCBParams {
GattAttribute::Handle_t charHandle;
enum Type {
GATTS_CHAR_OP_INVALID = 0x00, /**< Invalid Operation. */
GATTS_CHAR_OP_WRITE_REQ = 0x01, /**< Write Request. */
GATTS_CHAR_OP_WRITE_CMD = 0x02, /**< Write Command. */
GATTS_CHAR_OP_SIGN_WRITE_CMD = 0x03, /**< Signed Write Command. */
GATTS_CHAR_OP_PREP_WRITE_REQ = 0x04, /**< Prepare Write Request. */
GATTS_CHAR_OP_EXEC_WRITE_REQ_CANCEL = 0x05, /**< Execute Write Request: Cancel all prepared writes. */
GATTS_CHAR_OP_EXEC_WRITE_REQ_NOW = 0x06, /**< Execute Write Request: Immediately execute all prepared writes. */
} op; /**< Type of write operation, */
uint16_t offset; /**< Offset for the write operation. */
uint16_t len; /**< Length of the incoming data. */
const uint8_t *data; /**< Incoming data, variable length. */
struct GattWriteCallbackParams {
enum WriteOp_t {
OP_INVALID = 0x00, /**< Invalid Operation. */
OP_WRITE_REQ = 0x01, /**< Write Request. */
OP_WRITE_CMD = 0x02, /**< Write Command. */
OP_SIGN_WRITE_CMD = 0x03, /**< Signed Write Command. */
OP_PREP_WRITE_REQ = 0x04, /**< Prepare Write Request. */
OP_EXEC_WRITE_REQ_CANCEL = 0x05, /**< Execute Write Request: Cancel all prepared writes. */
OP_EXEC_WRITE_REQ_NOW = 0x06, /**< Execute Write Request: Immediately execute all prepared writes. */
};
GattAttribute::Handle_t handle;
WriteOp_t writeOp; /**< Type of write operation, */
uint16_t offset; /**< Offset for the write operation. */
uint16_t len;
const uint8_t *data; /* @note: data might not persist beyond the callback; make a local copy if needed. */
};
struct GattCharacteristicReadCBParams {
GattAttribute::Handle_t charHandle;
enum Type {
GATTS_CHAR_OP_INVALID = 0x00, /**< Invalid Operation. */
GATTS_CHAR_OP_READ_REQ = 0x0A, /**< Read Request. */
} op; /**< Type of write operation, */
uint16_t offset; /**< Offset for the read operation. */
uint16_t *len; /**< Length of the outgoing data. */
uint8_t *data; /**< Outgoing data, variable length. */
struct GattReadCallbackParams {
GattAttribute::Handle_t handle;
uint16_t offset; /**< Offset for the read operation. */
uint16_t len;
const uint8_t *data; /* @note: data might not persist beyond the callback; make a local copy if needed. */
};
enum GattCharacteristicAuthCBReply_t {
enum GattAuthCallbackReply_t {
AUTH_CALLBACK_REPLY_SUCCESS = 0x00, /**< Success. */
AUTH_CALLBACK_REPLY_ATTERR_INVALID_HANDLE = 0x0101, /**< ATT Error: Invalid Attribute Handle. */
AUTH_CALLBACK_REPLY_ATTERR_READ_NOT_PERMITTED = 0x0102, /**< ATT Error: Read not permitted. */
@ -59,22 +57,22 @@ enum GattCharacteristicAuthCBReply_t {
AUTH_CALLBACK_REPLY_ATTERR_INSUF_RESOURCES = 0x0111, /**< ATT Error: Encrypted link required. */
};
struct GattCharacteristicWriteAuthCBParams {
GattAttribute::Handle_t charHandle;
struct GattWriteAuthCallbackParams {
GattAttribute::Handle_t handle;
uint16_t offset; /**< Offset for the write operation. */
uint16_t len; /**< Length of the incoming data. */
const uint8_t *data; /**< Incoming data, variable length. */
GattCharacteristicAuthCBReply_t authorizationReply; /* This is the out parameter which needs to be set to true by the callback if the
* request is to proceed; false otherwise. */
GattAuthCallbackReply_t authorizationReply; /* This is the out parameter which needs to be set to true by the callback if the
* request is to proceed; false otherwise. */
};
struct GattCharacteristicReadAuthCBParams {
GattAttribute::Handle_t charHandle;
struct GattReadAuthCallbackParams {
GattAttribute::Handle_t handle;
uint16_t offset; /**< Offset for the read operation. */
uint16_t len; /**< Optional: new length of the outgoing data. */
uint8_t *data; /**< Optional: new outgoing data. Leave at NULL if data is unchanged. */
GattCharacteristicAuthCBReply_t authorizationReply; /* This is the out parameter which needs to be set to true by the callback if the
* request is to proceed; false otherwise. */
GattAuthCallbackReply_t authorizationReply; /* This is the out parameter which needs to be set to true by the callback if the
* request is to proceed; false otherwise. */
};
#endif /*__GATT_CHARACTERISTIC_CALLBACK_PARAMS_H__*/
#endif /*__GATT_CALLBACK_PARAM_TYPES_H__*/

18
public/GattCharacteristic.h
View file

@ -19,7 +19,7 @@
#include "Gap.h"
#include "GattAttribute.h"
#include "GattCharacteristicCallbackParams.h"
#include "GattCallbackParamTypes.h"
#include "FunctionPointerWithContext.h"
class GattCharacteristic {
@ -355,21 +355,21 @@ public:
/**
* Authorization.
*/
void setWriteAuthorizationCallback(void (*callback)(GattCharacteristicWriteAuthCBParams *)) {
void setWriteAuthorizationCallback(void (*callback)(GattWriteAuthCallbackParams *)) {
writeAuthorizationCallback.attach(callback);
enabledWriteAuthorization = true;
}
template <typename T>
void setWriteAuthorizationCallback(T *object, void (T::*member)(GattCharacteristicWriteAuthCBParams *)) {
void setWriteAuthorizationCallback(T *object, void (T::*member)(GattWriteAuthCallbackParams *)) {
writeAuthorizationCallback.attach(object, member);
enabledWriteAuthorization = true;
}
void setReadAuthorizationCallback(void (*callback)(GattCharacteristicReadAuthCBParams *)) {
void setReadAuthorizationCallback(void (*callback)(GattReadAuthCallbackParams *)) {
readAuthorizationCallback.attach(callback);
enabledReadAuthorization = true;
}
template <typename T>
void setReadAuthorizationCallback(T *object, void (T::*member)(GattCharacteristicReadAuthCBParams *)) {
void setReadAuthorizationCallback(T *object, void (T::*member)(GattReadAuthCallbackParams *)) {
readAuthorizationCallback.attach(object, member);
enabledReadAuthorization = true;
}
@ -380,7 +380,7 @@ public:
* @param params to capture the context of the write-auth request; and also contains an out-parameter for reply.
* @return true if the write is authorized to proceed.
*/
GattCharacteristicAuthCBReply_t authorizeWrite(GattCharacteristicWriteAuthCBParams *params) {
GattAuthCallbackReply_t authorizeWrite(GattWriteAuthCallbackParams *params) {
if (!isWriteAuthorizationEnabled()) {
return AUTH_CALLBACK_REPLY_SUCCESS;
}
@ -406,7 +406,7 @@ public:
*
* @return true if the read is authorized to proceed.
*/
GattCharacteristicAuthCBReply_t authorizeRead(GattCharacteristicReadAuthCBParams *params) {
GattAuthCallbackReply_t authorizeRead(GattReadAuthCallbackParams *params) {
if (!isReadAuthorizationEnabled()) {
return AUTH_CALLBACK_REPLY_SUCCESS;
}
@ -444,8 +444,8 @@ private:
bool enabledReadAuthorization;
bool enabledWriteAuthorization;
FunctionPointerWithContext<GattCharacteristicReadAuthCBParams *> readAuthorizationCallback;
FunctionPointerWithContext<GattCharacteristicWriteAuthCBParams *> writeAuthorizationCallback;
FunctionPointerWithContext<GattReadAuthCallbackParams *> readAuthorizationCallback;
FunctionPointerWithContext<GattWriteAuthCallbackParams *> writeAuthorizationCallback;
private:
/* disallow copy and assignment */

104
public/GattClient.h Normal file
View file

@ -0,0 +1,104 @@
/* mbed Microcontroller Library
* Copyright (c) 2006-2013 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __GATT_CLIENT_H__
#define __GATT_CLIENT_H__
#include "Gap.h"
#include "GattAttribute.h"
#include "ServiceDiscovery.h"
#include "GattCallbackParamTypes.h"
class GattClient {
public:
typedef void (*ReadCallback_t)(const GattReadCallbackParams *params);
enum WriteOp_t {
GATT_OP_WRITE_REQ = 0x01, /**< Write Request. */
GATT_OP_WRITE_CMD = 0x02, /**< Write Command. */
};
typedef void (*WriteCallback_t)(const GattWriteCallbackParams *params);
public:
/**
* Launch service discovery. Once launched, service discovery will remain
* active with callbacks being issued back into the application for matching
* services/characteristics. isActive() can be used to determine status; and
* a termination callback (if setup) will be invoked at the end. Service
* discovery can be terminated prematurely if needed using terminate().
*
* @param connectionHandle
* Handle for the connection with the peer.
* @param sc
* This is the application callback for matching service.
* @param cc
* This is the application callback for matching characteristic.
* @param matchingServiceUUID
* UUID based filter for specifying a service in which the application is
* interested.
* @param matchingCharacteristicUUIDIn
* UUID based filter for specifying characteristic in which the application
* is interested.
*
* @Note Using wildcard values for both service-UUID and characteristic-
* UUID will result in complete service discovery--callbacks being
* called for every service and characteristic.
*
* @return
* BLE_ERROR_NONE if service discovery is launched successfully; else an appropriate error.
*/
virtual ble_error_t launchServiceDiscovery(Gap::Handle_t connectionHandle,
ServiceDiscovery::ServiceCallback_t sc = NULL,
ServiceDiscovery::CharacteristicCallback_t cc = NULL,
const UUID &matchingServiceUUID = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN),
const UUID &matchingCharacteristicUUIDIn = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN)) = 0;
virtual void onServiceDiscoveryTermination(ServiceDiscovery::TerminationCallback_t callback) = 0;
/**
* Is service-discovery currently active?
*/
virtual bool isServiceDiscoveryActive(void) const = 0;
/**
* Terminate an ongoing service-discovery. This should result in an
* invocation of the TerminationCallback if service-discovery is active.
*/
virtual void terminateServiceDiscovery(void) = 0;
/* Initiate a Gatt Client read procedure by attribute-handle.*/
virtual ble_error_t read(Gap::Handle_t connHandle, GattAttribute::Handle_t attributeHandle, uint16_t offset) const = 0;
virtual ble_error_t write(GattClient::WriteOp_t cmd,
Gap::Handle_t connHandle,
GattAttribute::Handle_t attributeHandle,
size_t length,
const uint8_t *value) const = 0;
protected:
GattClient() {
/* empty */
}
private:
/* disallow copy and assignment */
GattClient(const GattClient &);
GattClient& operator=(const GattClient &);
};
#endif // ifndef __GATT_CLIENT_H__

18
public/GattServer.h
View file

@ -21,7 +21,7 @@
#include "GattService.h"
#include "GattAttribute.h"
#include "GattServerEvents.h"
#include "GattCharacteristicCallbackParams.h"
#include "GattCallbackParamTypes.h"
#include "CallChainOfFunctionPointersWithContext.h"
class GattServer {
@ -62,9 +62,9 @@ public:
void setOnDataSent(T *objPtr, void (T::*memberPtr)(unsigned count)) {
onDataSent.add(objPtr, memberPtr);
}
void setOnDataWritten(void (*callback)(const GattCharacteristicWriteCBParams *eventDataP)) {onDataWritten.add(callback);}
void setOnDataWritten(void (*callback)(const GattWriteCallbackParams *eventDataP)) {onDataWritten.add(callback);}
template <typename T>
void setOnDataWritten(T *objPtr, void (T::*memberPtr)(const GattCharacteristicWriteCBParams *context)) {
void setOnDataWritten(T *objPtr, void (T::*memberPtr)(const GattWriteCallbackParams *context)) {
onDataWritten.add(objPtr, memberPtr);
}
@ -75,7 +75,7 @@ public:
virtual bool isOnDataReadAvailable() const {
return false;
}
ble_error_t setOnDataRead(void (*callback)(const GattCharacteristicReadCBParams *eventDataP)) {
ble_error_t setOnDataRead(void (*callback)(const GattReadCallbackParams *eventDataP)) {
if (!isOnDataReadAvailable()) {
return BLE_ERROR_NOT_IMPLEMENTED;
}
@ -84,7 +84,7 @@ public:
return BLE_ERROR_NONE;
}
template <typename T>
ble_error_t setOnDataRead(T *objPtr, void (T::*memberPtr)(const GattCharacteristicReadCBParams *context)) {
ble_error_t setOnDataRead(T *objPtr, void (T::*memberPtr)(const GattReadCallbackParams *context)) {
if (!isOnDataReadAvailable()) {
return BLE_ERROR_NOT_IMPLEMENTED;
}
@ -97,13 +97,13 @@ public:
void setOnConfirmationReceived(EventCallback_t callback) {onConfirmationReceived = callback;}
protected:
void handleDataWrittenEvent(const GattCharacteristicWriteCBParams *params) {
void handleDataWrittenEvent(const GattWriteCallbackParams *params) {
if (onDataWritten.hasCallbacksAttached()) {
onDataWritten.call(params);
}
}
void handleDataReadEvent(const GattCharacteristicReadCBParams *params) {
void handleDataReadEvent(const GattReadCallbackParams *params) {
if (onDataRead.hasCallbacksAttached()) {
onDataRead.call(params);
}
@ -143,8 +143,8 @@ protected:
private:
CallChainOfFunctionPointersWithContext<unsigned> onDataSent;
CallChainOfFunctionPointersWithContext<const GattCharacteristicWriteCBParams *> onDataWritten;
CallChainOfFunctionPointersWithContext<const GattCharacteristicReadCBParams *> onDataRead;
CallChainOfFunctionPointersWithContext<const GattWriteCallbackParams *> onDataWritten;
CallChainOfFunctionPointersWithContext<const GattReadCallbackParams *> onDataRead;
EventCallback_t onUpdatesEnabled;
EventCallback_t onUpdatesDisabled;
EventCallback_t onConfirmationReceived;

138
public/ServiceDiscovery.h Normal file
View file

@ -0,0 +1,138 @@
/* mbed Microcontroller Library
* Copyright (c) 2006-2013 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __SERVICE_DISOVERY_H__
#define __SERVICE_DISOVERY_H__
#include "UUID.h"
#include "Gap.h"
#include "GattAttribute.h"
class DiscoveredService;
class DiscoveredCharacteristic;
class ServiceDiscovery {
public:
/*
* Exposed application callback types.
*/
/**
* Callback type for when a matching Service is found during service-
* discovery. The receiving function is passed in a pointer to a
* DiscoveredService object which will remain valid for the lifetime of the
* callback. Memory for this object is owned by the BLE_API eventing
* framework. The application can safely make a persistent shallow-copy of
* this object in order to work with the service beyond the callback.
*/
typedef void (*ServiceCallback_t)(const DiscoveredService *);
/**
* Callback type for when a matching Characteristic is found during service-
* discovery. The receiving function is passed in a pointer to a
* DiscoveredCharacteristic object which will remain valid for the lifetime
* of the callback. Memory for this object is owned by the BLE_API eventing
* framework. The application can safely make a persistent shallow-copy of
* this object in order to work with the characteristic beyond the callback.
*/
typedef void (*CharacteristicCallback_t)(const DiscoveredCharacteristic *);
/**
* Callback type for when serviceDiscovery terminates.
*/
typedef void (*TerminationCallback_t)(Gap::Handle_t connectionHandle);
public:
/**
* Launch service discovery. Once launched, service discovery will remain
* active with callbacks being issued back into the application for matching
* services/characteristics. isActive() can be used to determine status; and
* a termination callback (if setup) will be invoked at the end. Service
* discovery can be terminated prematurely if needed using terminate().
*
* @param connectionHandle
* Handle for the connection with the peer.
* @param sc
* This is the application callback for matching service. Taken as
* NULL by default. Note: service discovery may still be active
* when this callback is issued; calling asynchronous BLE-stack
* APIs from within this application callback might cause the
* stack to abort service discovery. If this becomes an issue, it
* may be better to make local copy of the discoveredService and
* wait for service discovery to terminate before operating on the
* service.
* @param cc
* This is the application callback for matching characteristic.
* Taken as NULL by default. Note: service discovery may still be
* active when this callback is issued; calling asynchronous
* BLE-stack APIs from within this application callback might cause
* the stack to abort service discovery. If this becomes an issue,
* it may be better to make local copy of the discoveredCharacteristic
* and wait for service discovery to terminate before operating on the
* characteristic.
* @param matchingServiceUUID
* UUID based filter for specifying a service in which the application is
* interested. By default it is set as the wildcard UUID_UNKNOWN,
* in which case it matches all services. If characteristic-UUID
* filter (below) is set to the wildcard value, then a service
* callback will be invoked for the matching service (or for every
* service if the service filter is a wildcard).
* @param matchingCharacteristicUUIDIn
* UUID based filter for specifying characteristic in which the application
* is interested. By default it is set as the wildcard UUID_UKNOWN
* to match against any characteristic. If both service-UUID
* filter and characteristic-UUID filter are used with non- wildcard
* values, then only a single characteristic callback is
* invoked for the matching characteristic.
*
* @Note Using wildcard values for both service-UUID and characteristic-
* UUID will result in complete service discovery--callbacks being
* called for every service and characteristic.
*
* @return
* BLE_ERROR_NONE if service discovery is launched successfully; else an appropriate error.
*/
virtual ble_error_t launch(Gap::Handle_t connectionHandle,
ServiceCallback_t sc = NULL,
CharacteristicCallback_t cc = NULL,
const UUID &matchingServiceUUID = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN),
const UUID &matchingCharacteristicUUIDIn = UUID::ShortUUIDBytes_t(BLE_UUID_UNKNOWN)) = 0;
/**
* Is service-discovery currently active?
*/
virtual bool isActive(void) const = 0;
/**
* Terminate an ongoing service-discovery. This should result in an
* invocation of the TerminationCallback if service-discovery is active.
*/
virtual void terminate(void) = 0;
/**
* Setup callback to be invoked when service discovery is terminated.
*/
virtual void onTermination(TerminationCallback_t callback) = 0;
protected:
Gap::Handle_t connHandle; /**< Connection handle as provided by the SoftDevice. */
UUID matchingServiceUUID;
ServiceCallback_t serviceCallback;
UUID matchingCharacteristicUUID;
CharacteristicCallback_t characteristicCallback;
};
#endif // ifndef __SERVICE_DISOVERY_H__

6
public/UUID.h
View file

@ -17,6 +17,7 @@
#ifndef __UUID_H__
#define __UUID_H__
#include <stdint.h>
#include <string.h>
#include "blecommon.h"
@ -28,9 +29,10 @@ public:
UUID_TYPE_LONG = 1 // Full 128-bit UUID
};
typedef uint16_t ShortUUIDBytes_t;
static const unsigned LENGTH_OF_LONG_UUID = 16;
typedef uint16_t ShortUUIDBytes_t;
typedef uint8_t LongUUIDBytes_t[LENGTH_OF_LONG_UUID];
typedef uint8_t LongUUIDBytes_t[LENGTH_OF_LONG_UUID];
public:
/**

4
services/DFUService.h
View file

@ -94,8 +94,8 @@ public:
* @param[in] params
* Information about the characterisitc being updated.
*/
virtual void onDataWritten(const GattCharacteristicWriteCBParams *params) {
if (params->charHandle == controlPoint.getValueHandle()) {
virtual void onDataWritten(const GattWriteCallbackParams *params) {
if (params->handle == controlPoint.getValueHandle()) {
/* At present, writing anything will do the trick--this needs to be improved. */
if (handoverCallback) {
handoverCallback();

4
services/HeartRateService.h
View file

@ -114,8 +114,8 @@ public:
* @param[in] params
* Information about the characterisitc being updated.
*/
virtual void onDataWritten(const GattCharacteristicWriteCBParams *params) {
if (params->charHandle == controlPoint.getValueAttribute().getHandle()) {
virtual void onDataWritten(const GattWriteCallbackParams *params) {
if (params->handle == controlPoint.getValueAttribute().getHandle()) {
/* Do something here if the new value is 1; else you can override this method by