xiao sun
/
BLE_API
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of
BLE_API
by 
Bluetooth Low Energy
Revision 669:7179b4a5aa7d, committed 2015-06-19
- Comitter:
- rgrover1
- Date:
- Fri Jun 19 15:53:01 2015 +0100
- Parent:
- 668:222cc9525163
- Child:
- 670:5e4aecd9af5b
- Commit message:
- Synchronized with git rev 9bcd7433
Author: Rohit Grover
Rename BLEDevice as BLE. Retain an alias to BLEDevice for the sake of compatibility with old code.
Changed in this revision
--- a/common/BLEDeviceInstanceBase.h Fri Jun 19 15:53:01 2015 +0100
+++ b/common/BLEDeviceInstanceBase.h Fri Jun 19 15:53:01 2015 +0100
@@ -17,12 +17,6 @@
#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,20 +24,16 @@
class BLEDeviceInstanceBase
{
public:
+ virtual ble_error_t init(void) = 0;
+ virtual ble_error_t shutdown(void) = 0;
+ virtual ble_error_t reset(void) = 0;
virtual const char *getVersion(void) = 0;
virtual Gap& getGap() = 0;
virtual GattServer& getGattServer() = 0;
- virtual GattClient& getGattClient() = 0;
-
- virtual ble_error_t init(void) = 0;
- virtual ble_error_t shutdown(void) = 0;
- virtual ble_error_t reset(void) = 0;
virtual ble_error_t initializeSecurity(bool enableBonding = true,
bool requireMITM = true,
Gap::SecurityIOCapabilities_t iocaps = Gap::IO_CAPS_NONE,
const Gap::Passkey_t passkey = NULL) = 0;
- virtual ble_error_t setTxPower(int8_t txPower) = 0;
- virtual void getPermittedTxPowerValues(const int8_t **, size_t *) = 0;
virtual void waitForEvent(void) = 0;
};
--- a/common/DiscoveredCharacteristic.cpp Fri Jun 19 15:53:01 2015 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,63 +0,0 @@
-/* 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);
-}
\ No newline at end of file
--- a/common/blecommon.h Fri Jun 19 15:53:01 2015 +0100
+++ b/common/blecommon.h Fri Jun 19 15:53:01 2015 +0100
@@ -21,6 +21,8 @@
extern "C" {
#endif
+#include <stdint.h>
+#include <stddef.h>
/** @defgroup BLE_UUID_VALUES Assigned Values for BLE UUIDs
* @{ */
@@ -113,18 +115,18 @@
\brief Error codes for the BLE API
*/
/**************************************************************************/
-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. */
-};
+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;
#ifdef __cplusplus
}
--- a/public/BLEDevice.h Fri Jun 19 15:53:01 2015 +0100
+++ b/public/BLEDevice.h Fri Jun 19 15:53:01 2015 +0100
@@ -20,19 +20,14 @@
#include "blecommon.h"
#include "Gap.h"
#include "GattServer.h"
-#include "GattClient.h"
+#include "GapScanningParams.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.
*/
-class BLEDevice
+class BLE
{
public:
/**
@@ -44,7 +39,7 @@
* setup (such as clocks or power-modes) which happens early on during
* system startup. It may not be safe to call init() from global static
* context where ordering is compiler specific and can't be guaranteed--it
- * is safe to call BLEDevice::init() from within main().
+ * is safe to call BLE::init() from within main().
*/
ble_error_t init();
@@ -321,25 +316,6 @@
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
* onDisconnection callback.
@@ -392,8 +368,8 @@
* @Note: it is also possible to setup a callback into a member function of
* some object.
*/
- void onDataWritten(void (*callback)(const GattWriteCallbackParams *eventDataP));
- template <typename T> void onDataWritten(T * objPtr, void (T::*memberPtr)(const GattWriteCallbackParams *context));
+ void onDataWritten(void (*callback)(const GattCharacteristicWriteCBParams *eventDataP));
+ template <typename T> void onDataWritten(T * objPtr, void (T::*memberPtr)(const GattCharacteristicWriteCBParams *context));
/**
* Setup a callback for when a characteristic is being read by a client.
@@ -413,8 +389,8 @@
* @return BLE_ERROR_NOT_IMPLEMENTED if this functionality isn't available;
* else BLE_ERROR_NONE.
*/
- ble_error_t onDataRead(void (*callback)(const GattReadCallbackParams *eventDataP));
- template <typename T> ble_error_t onDataRead(T * objPtr, void (T::*memberPtr)(const GattReadCallbackParams *context));
+ ble_error_t onDataRead(void (*callback)(const GattCharacteristicReadCBParams *eventDataP));
+ template <typename T> ble_error_t onDataRead(T * objPtr, void (T::*memberPtr)(const GattCharacteristicReadCBParams *context));
void onUpdatesEnabled(GattServer::EventCallback_t callback);
void onUpdatesDisabled(GattServer::EventCallback_t callback);
@@ -469,11 +445,7 @@
/**
* 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
@@ -639,80 +611,8 @@
*/
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:
- BLEDevice() : transport(createBLEDeviceInstance()), advParams(), advPayload(), scanResponse(), needToSetAdvPayload(true), scanningParams() {
+ BLE() : transport(createBLEDeviceInstance()), advParams(), advPayload(), scanResponse(), needToSetAdvPayload(true), scanningParams() {
advPayload.clear();
scanResponse.clear();
}
@@ -732,42 +632,45 @@
GapScanningParams scanningParams;
};
+typedef BLE BLEDevice; /* DEPRECATED. This type alias is retained for the sake of compatibilty with older
+ * code. Will be dropped at some point soon.*/
+
/* BLEDevice methods. Most of these simply forward the calls to the underlying
* transport.*/
inline ble_error_t
-BLEDevice::reset(void)
+BLE::reset(void)
{
return transport->reset();
}
inline ble_error_t
-BLEDevice::shutdown(void)
+BLE::shutdown(void)
{
clearAdvertisingPayload();
return transport->shutdown();
}
inline ble_error_t
-BLEDevice::setAddress(Gap::AddressType_t type, const Gap::Address_t address)
+BLE::setAddress(Gap::AddressType_t type, const Gap::Address_t address)
{
return transport->getGap().setAddress(type, address);
}
inline ble_error_t
-BLEDevice::getAddress(Gap::AddressType_t *typeP, Gap::Address_t address)
+BLE::getAddress(Gap::AddressType_t *typeP, Gap::Address_t address)
{
return transport->getGap().getAddress(typeP, address);
}
inline void
-BLEDevice::setAdvertisingType(GapAdvertisingParams::AdvertisingType advType)
+BLE::setAdvertisingType(GapAdvertisingParams::AdvertisingType advType)
{
advParams.setAdvertisingType(advType);
}
inline void
-BLEDevice::setAdvertisingInterval(uint16_t interval)
+BLE::setAdvertisingInterval(uint16_t interval)
{
if (interval == 0) {
stopAdvertising();
@@ -778,54 +681,54 @@
}
inline uint16_t
-BLEDevice::getMinAdvertisingInterval(void) const {
+BLE::getMinAdvertisingInterval(void) const {
return transport->getGap().getMinAdvertisingInterval();
}
inline uint16_t
-BLEDevice::getMinNonConnectableAdvertisingInterval(void) const {
+BLE::getMinNonConnectableAdvertisingInterval(void) const {
return transport->getGap().getMinNonConnectableAdvertisingInterval();
}
inline uint16_t
-BLEDevice::getMaxAdvertisingInterval(void) const {
+BLE::getMaxAdvertisingInterval(void) const {
return transport->getGap().getMaxAdvertisingInterval();
}
inline void
-BLEDevice::setAdvertisingTimeout(uint16_t timeout)
+BLE::setAdvertisingTimeout(uint16_t timeout)
{
advParams.setTimeout(timeout);
}
inline void
-BLEDevice::setAdvertisingParams(const GapAdvertisingParams &newAdvParams)
+BLE::setAdvertisingParams(const GapAdvertisingParams &newAdvParams)
{
advParams = newAdvParams;
}
inline const GapAdvertisingParams &
-BLEDevice::getAdvertisingParams(void) const
+BLE::getAdvertisingParams(void) const
{
return advParams;
}
inline void
-BLEDevice::clearAdvertisingPayload(void)
+BLE::clearAdvertisingPayload(void)
{
needToSetAdvPayload = true;
advPayload.clear();
}
inline ble_error_t
-BLEDevice::accumulateAdvertisingPayload(uint8_t flags)
+BLE::accumulateAdvertisingPayload(uint8_t flags)
{
needToSetAdvPayload = true;
return advPayload.addFlags(flags);
}
inline ble_error_t
-BLEDevice::accumulateAdvertisingPayload(GapAdvertisingData::Appearance app)
+BLE::accumulateAdvertisingPayload(GapAdvertisingData::Appearance app)
{
needToSetAdvPayload = true;
transport->getGap().setAppearance(app);
@@ -833,14 +736,14 @@
}
inline ble_error_t
-BLEDevice::accumulateAdvertisingPayloadTxPower(int8_t txPower)
+BLE::accumulateAdvertisingPayloadTxPower(int8_t txPower)
{
needToSetAdvPayload = true;
return advPayload.addTxPower(txPower);
}
inline ble_error_t
-BLEDevice::accumulateAdvertisingPayload(GapAdvertisingData::DataType type, const uint8_t *data, uint8_t len)
+BLE::accumulateAdvertisingPayload(GapAdvertisingData::DataType type, const uint8_t *data, uint8_t len)
{
needToSetAdvPayload = true;
if (type == GapAdvertisingData::COMPLETE_LOCAL_NAME) {
@@ -850,27 +753,27 @@
}
inline ble_error_t
-BLEDevice::accumulateScanResponse(GapAdvertisingData::DataType type, const uint8_t *data, uint8_t len)
+BLE::accumulateScanResponse(GapAdvertisingData::DataType type, const uint8_t *data, uint8_t len)
{
needToSetAdvPayload = true;
return scanResponse.addData(type, data, len);
}
inline void
-BLEDevice::clearScanResponse(void)
+BLE::clearScanResponse(void)
{
needToSetAdvPayload = true;
scanResponse.clear();
}
inline ble_error_t
-BLEDevice::setAdvertisingPayload(void) {
+BLE::setAdvertisingPayload(void) {
needToSetAdvPayload = false;
return transport->getGap().setAdvertisingData(advPayload, scanResponse);
}
inline ble_error_t
-BLEDevice::setAdvertisingData(const GapAdvertisingData& newPayload)
+BLE::setAdvertisingData(const GapAdvertisingData& newPayload)
{
advPayload = newPayload;
@@ -878,12 +781,12 @@
}
inline const GapAdvertisingData &
-BLEDevice::getAdvertisingData(void) const {
+BLE::getAdvertisingData(void) const {
return advPayload;
}
inline ble_error_t
-BLEDevice::startAdvertising(void)
+BLE::startAdvertising(void)
{
ble_error_t rc;
if ((rc = transport->getGattServer().initializeGATTDatabase()) != BLE_ERROR_NONE) {
@@ -899,13 +802,13 @@
}
inline ble_error_t
-BLEDevice::stopAdvertising(void)
+BLE::stopAdvertising(void)
{
return transport->getGap().stopAdvertising();
}
inline ble_error_t
-BLEDevice::setScanParams(uint16_t interval, uint16_t window, uint16_t timeout, bool activeScanning) {
+BLE::setScanParams(uint16_t interval, uint16_t window, uint16_t timeout, bool activeScanning) {
ble_error_t rc;
if (((rc = scanningParams.setInterval(interval)) == BLE_ERROR_NONE) &&
((rc = scanningParams.setWindow(window)) == BLE_ERROR_NONE) &&
@@ -918,324 +821,275 @@
}
inline ble_error_t
-BLEDevice::setScanInterval(uint16_t interval) {
+BLE::setScanInterval(uint16_t interval) {
return scanningParams.setInterval(interval);
}
inline ble_error_t
-BLEDevice::setScanWindow(uint16_t window) {
+BLE::setScanWindow(uint16_t window) {
return scanningParams.setWindow(window);
}
inline ble_error_t
-BLEDevice::setScanTimeout(uint16_t timeout) {
+BLE::setScanTimeout(uint16_t timeout) {
return scanningParams.setTimeout(timeout);
}
inline void
-BLEDevice::setActiveScan(bool activeScanning) {
+BLE::setActiveScan(bool activeScanning) {
return scanningParams.setActiveScanning(activeScanning);
}
inline ble_error_t
-BLEDevice::startScan(void (*callback)(const Gap::AdvertisementCallbackParams_t *params)) {
+BLE::startScan(void (*callback)(const Gap::AdvertisementCallbackParams_t *params)) {
return transport->getGap().startScan(scanningParams, callback);
}
template<typename T>
inline ble_error_t
-BLEDevice::startScan(T *object, void (T::*memberCallback)(const Gap::AdvertisementCallbackParams_t *params)) {
+BLE::startScan(T *object, void (T::*memberCallback)(const Gap::AdvertisementCallbackParams_t *params)) {
return transport->getGap().startScan(scanningParams, object, memberCallback);
}
inline ble_error_t
-BLEDevice::stopScan(void) {
+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
-BLEDevice::disconnect(Gap::DisconnectionReason_t reason)
+BLE::disconnect(Gap::DisconnectionReason_t reason)
{
return transport->getGap().disconnect(reason);
}
inline void
-BLEDevice::onTimeout(Gap::EventCallback_t timeoutCallback)
+BLE::onTimeout(Gap::EventCallback_t timeoutCallback)
{
transport->getGap().setOnTimeout(timeoutCallback);
}
inline void
-BLEDevice::onConnection(Gap::ConnectionEventCallback_t connectionCallback)
+BLE::onConnection(Gap::ConnectionEventCallback_t connectionCallback)
{
transport->getGap().setOnConnection(connectionCallback);
}
inline void
-BLEDevice::onDisconnection(Gap::DisconnectionEventCallback_t disconnectionCallback)
+BLE::onDisconnection(Gap::DisconnectionEventCallback_t disconnectionCallback)
{
transport->getGap().setOnDisconnection(disconnectionCallback);
}
template<typename T>
inline void
-BLEDevice::addToDisconnectionCallChain(T *tptr, void (T::*mptr)(void)) {
+BLE::addToDisconnectionCallChain(T *tptr, void (T::*mptr)(void)) {
transport->getGap().addToDisconnectionCallChain(tptr, mptr);
}
inline void
-BLEDevice::onDataSent(void (*callback)(unsigned count)) {
+BLE::onDataSent(void (*callback)(unsigned count)) {
transport->getGattServer().setOnDataSent(callback);
}
template <typename T> inline void
-BLEDevice::onDataSent(T *objPtr, void (T::*memberPtr)(unsigned count)) {
+BLE::onDataSent(T *objPtr, void (T::*memberPtr)(unsigned count)) {
transport->getGattServer().setOnDataSent(objPtr, memberPtr);
}
inline void
-BLEDevice::onDataWritten(void (*callback)(const GattWriteCallbackParams *eventDataP)) {
+BLE::onDataWritten(void (*callback)(const GattCharacteristicWriteCBParams *eventDataP)) {
transport->getGattServer().setOnDataWritten(callback);
}
template <typename T> inline void
-BLEDevice::onDataWritten(T *objPtr, void (T::*memberPtr)(const GattWriteCallbackParams *context)) {
+BLE::onDataWritten(T *objPtr, void (T::*memberPtr)(const GattCharacteristicWriteCBParams *context)) {
transport->getGattServer().setOnDataWritten(objPtr, memberPtr);
}
inline ble_error_t
-BLEDevice::onDataRead(void (*callback)(const GattReadCallbackParams *eventDataP)) {
+BLE::onDataRead(void (*callback)(const GattCharacteristicReadCBParams *eventDataP)) {
return transport->getGattServer().setOnDataRead(callback);
}
template <typename T> inline ble_error_t
-BLEDevice::onDataRead(T *objPtr, void (T::*memberPtr)(const GattReadCallbackParams *context)) {
+BLE::onDataRead(T *objPtr, void (T::*memberPtr)(const GattCharacteristicReadCBParams *context)) {
return transport->getGattServer().setOnDataRead(objPtr, memberPtr);
}
inline void
-BLEDevice::onUpdatesEnabled(GattServer::EventCallback_t callback)
+BLE::onUpdatesEnabled(GattServer::EventCallback_t callback)
{
transport->getGattServer().setOnUpdatesEnabled(callback);
}
inline void
-BLEDevice::onUpdatesDisabled(GattServer::EventCallback_t callback)
+BLE::onUpdatesDisabled(GattServer::EventCallback_t callback)
{
transport->getGattServer().setOnUpdatesDisabled(callback);
}
inline void
-BLEDevice::onConfirmationReceived(GattServer::EventCallback_t callback)
+BLE::onConfirmationReceived(GattServer::EventCallback_t callback)
{
transport->getGattServer().setOnConfirmationReceived(callback);
}
inline void
-BLEDevice::onRadioNotification(Gap::RadioNotificationEventCallback_t callback)
+BLE::onRadioNotification(Gap::RadioNotificationEventCallback_t callback)
{
transport->getGap().setOnRadioNotification(callback);
}
inline ble_error_t
-BLEDevice::addService(GattService &service)
+BLE::addService(GattService &service)
{
return transport->getGattServer().addService(service);
}
inline Gap::GapState_t
-BLEDevice::getGapState(void) const
+BLE::getGapState(void) const
{
return transport->getGap().getState();
}
-inline ble_error_t BLEDevice::readCharacteristicValue(GattAttribute::Handle_t attributeHandle, uint8_t *buffer, uint16_t *lengthP)
+inline ble_error_t
+BLE::readCharacteristicValue(GattAttribute::Handle_t attributeHandle, uint8_t *buffer, uint16_t *lengthP)
{
return transport->getGattServer().readValue(attributeHandle, buffer, lengthP);
}
-inline ble_error_t BLEDevice::readCharacteristicValue(Gap::Handle_t connectionHandle,
- GattAttribute::Handle_t attributeHandle,
- uint8_t *buffer,
- uint16_t *lengthP)
+inline ble_error_t
+BLE::readCharacteristicValue(Gap::Handle_t connectionHandle, GattAttribute::Handle_t attributeHandle, uint8_t *buffer, uint16_t *lengthP)
{
return transport->getGattServer().readValue(connectionHandle, attributeHandle, buffer, lengthP);
}
inline ble_error_t
-BLEDevice::updateCharacteristicValue(GattAttribute::Handle_t attributeHandle, const uint8_t *value, uint16_t size, bool localOnly)
+BLE::updateCharacteristicValue(GattAttribute::Handle_t attributeHandle, const uint8_t *value, uint16_t size, bool localOnly)
{
return transport->getGattServer().updateValue(attributeHandle, const_cast<uint8_t *>(value), size, localOnly);
}
inline ble_error_t
-BLEDevice::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);
}
inline void
-BLEDevice::waitForEvent(void)
+BLE::waitForEvent(void)
{
transport->waitForEvent();
}
inline ble_error_t
-BLEDevice::getPreferredConnectionParams(Gap::ConnectionParams_t *params)
+BLE::getPreferredConnectionParams(Gap::ConnectionParams_t *params)
{
return transport->getGap().getPreferredConnectionParams(params);
}
inline ble_error_t
-BLEDevice::setPreferredConnectionParams(const Gap::ConnectionParams_t *params)
+BLE::setPreferredConnectionParams(const Gap::ConnectionParams_t *params)
{
return transport->getGap().setPreferredConnectionParams(params);
}
inline ble_error_t
-BLEDevice::updateConnectionParams(Gap::Handle_t handle, const Gap::ConnectionParams_t *params) {
+BLE::updateConnectionParams(Gap::Handle_t handle, const Gap::ConnectionParams_t *params) {
return transport->getGap().updateConnectionParams(handle, params);
}
inline const char *
-BLEDevice::getVersion(void)
+BLE::getVersion(void)
{
return transport->getVersion();
}
inline ble_error_t
-BLEDevice::setDeviceName(const uint8_t *deviceName)
+BLE::setDeviceName(const uint8_t *deviceName)
{
return transport->getGap().setDeviceName(deviceName);
}
inline ble_error_t
-BLEDevice::getDeviceName(uint8_t *deviceName, unsigned *lengthP)
+BLE::getDeviceName(uint8_t *deviceName, unsigned *lengthP)
{
return transport->getGap().getDeviceName(deviceName, lengthP);
}
inline ble_error_t
-BLEDevice::setAppearance(uint16_t appearance)
+BLE::setAppearance(uint16_t appearance)
{
return transport->getGap().setAppearance(appearance);
}
inline ble_error_t
-BLEDevice::getAppearance(uint16_t *appearanceP)
+BLE::getAppearance(uint16_t *appearanceP)
{
return transport->getGap().getAppearance(appearanceP);
}
inline ble_error_t
-BLEDevice::setTxPower(int8_t txPower)
+BLE::setTxPower(int8_t txPower)
{
- return transport->setTxPower(txPower);
+ return transport->getGap().setTxPower(txPower);
}
inline void
-BLEDevice::getPermittedTxPowerValues(const int8_t **valueArrayPP, size_t *countP)
+BLE::getPermittedTxPowerValues(const int8_t **valueArrayPP, size_t *countP)
{
- transport->getPermittedTxPowerValues(valueArrayPP, countP);
+ transport->getGap().getPermittedTxPowerValues(valueArrayPP, countP);
}
inline ble_error_t
-BLEDevice::initializeSecurity(bool enableBonding,
- bool requireMITM,
- Gap::SecurityIOCapabilities_t iocaps,
- const Gap::Passkey_t passkey)
+BLE::initializeSecurity(bool enableBonding,
+ bool requireMITM,
+ Gap::SecurityIOCapabilities_t iocaps,
+ const Gap::Passkey_t passkey)
{
return transport->initializeSecurity(enableBonding, requireMITM, iocaps, passkey);
}
inline void
-BLEDevice::onSecuritySetupInitiated(Gap::SecuritySetupInitiatedCallback_t callback)
+BLE::onSecuritySetupInitiated(Gap::SecuritySetupInitiatedCallback_t callback)
{
transport->getGap().setOnSecuritySetupInitiated(callback);
}
inline void
-BLEDevice::onSecuritySetupCompleted(Gap::SecuritySetupCompletedCallback_t callback)
+BLE::onSecuritySetupCompleted(Gap::SecuritySetupCompletedCallback_t callback)
{
transport->getGap().setOnSecuritySetupCompleted(callback);
}
inline void
-BLEDevice::onLinkSecured(Gap::LinkSecuredCallback_t callback)
+BLE::onLinkSecured(Gap::LinkSecuredCallback_t callback)
{
transport->getGap().setOnLinkSecured(callback);
}
inline void
-BLEDevice::onSecurityContextStored(Gap::HandleSpecificEvent_t callback)
+BLE::onSecurityContextStored(Gap::HandleSpecificEvent_t callback)
{
transport->getGap().setOnSecurityContextStored(callback);
}
inline void
-BLEDevice::onPasskeyDisplay(Gap::PasskeyDisplayCallback_t callback)
+BLE::onPasskeyDisplay(Gap::PasskeyDisplayCallback_t callback)
{
return transport->getGap().setOnPasskeyDisplay(callback);
}
inline ble_error_t
-BLEDevice::getLinkSecurity(Gap::Handle_t connectionHandle, Gap::LinkSecurityStatus_t *securityStatusP)
+BLE::getLinkSecurity(Gap::Handle_t connectionHandle, Gap::LinkSecurityStatus_t *securityStatusP)
{
return transport->getGap().getLinkSecurity(connectionHandle, securityStatusP);
}
inline ble_error_t
-BLEDevice::purgeAllBondingState(void)
+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__
\ No newline at end of file
--- a/public/DiscoveredCharacteristic.h Fri Jun 19 15:53:01 2015 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,161 +0,0 @@
-/* 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__*/
\ No newline at end of file
--- a/public/DiscoveredService.h Fri Jun 19 15:53:01 2015 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,71 +0,0 @@
-/* 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__*/
\ No newline at end of file
--- a/public/Gap.h Fri Jun 19 15:53:01 2015 +0100
+++ b/public/Gap.h Fri Jun 19 15:53:01 2015 +0100
@@ -17,16 +17,15 @@
#ifndef __GAP_H__
#define __GAP_H__
+#include "GapAdvertisingData.h"
+#include "GapAdvertisingParams.h"
#include "GapEvents.h"
#include "CallChain.h"
#include "FunctionPointerWithContext.h"
using namespace mbed;
-/* Forward declarations for classes which will only be used for pointers or references in the following. */
-class GapAdvertisingParams;
-class GapScanningParams;
-class GapAdvertisingData;
+class GapScanningParams; /* forward declaration */
class Gap {
public:
@@ -57,9 +56,12 @@
* transport library.
*/
enum DisconnectionReason_t {
- REMOTE_USER_TERMINATED_CONNECTION = 0x13,
- LOCAL_HOST_TERMINATED_CONNECTION = 0x16,
- CONN_INTERVAL_UNACCEPTABLE = 0x3B,
+ CONNECTION_TIMEOUT = 0x08,
+ REMOTE_USER_TERMINATED_CONNECTION = 0x13,
+ REMOTE_DEV_TERMINATION_DUE_TO_LOW_RESOURCES = 0x14, /**< Remote Device Terminated Connection due to low resources.*/
+ REMOTE_DEV_TERMINATION_DUE_TO_POWER_OFF = 0x15, /**< Remote Device Terminated Connection due to power off. */
+ LOCAL_HOST_TERMINATED_CONNECTION = 0x16,
+ CONN_INTERVAL_UNACCEPTABLE = 0x3B,
};
/* Describes the current state of the device (more than one bit can be set) */
@@ -77,49 +79,6 @@
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. */
@@ -185,7 +144,10 @@
}
typedef void (*EventCallback_t)(void);
- typedef void (*ConnectionEventCallback_t)(const ConnectionCallbackParams_t *params);
+ 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 (*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. */
@@ -194,12 +156,20 @@
typedef void (*LinkSecuredCallback_t)(Handle_t handle, SecurityMode_t securityMode);
typedef void (*PasskeyDisplayCallback_t)(Handle_t handle, const Passkey_t passkey);
- friend class BLEDevice;
+ 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;
-private:
+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;
@@ -207,10 +177,6 @@
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;
@@ -224,6 +190,9 @@
virtual ble_error_t setAppearance(uint16_t appearance) = 0;
virtual ble_error_t getAppearance(uint16_t *appearanceP) = 0;
+ virtual ble_error_t setTxPower(int8_t txPower) = 0;
+ virtual void getPermittedTxPowerValues(const int8_t **, size_t *) = 0;
+
ble_error_t startScan(const GapScanningParams &scanningParams, void (*callback)(const AdvertisementCallbackParams_t *params)) {
ble_error_t err = BLE_ERROR_NONE;
if (callback) {
@@ -247,7 +216,7 @@
return err;
}
-protected:
+public:
virtual ble_error_t startRadioScan(const GapScanningParams &scanningParams) = 0;
/* Event callback handlers */
@@ -311,7 +280,7 @@
template<typename T>
void addToDisconnectionCallChain(T *tptr, void (T::*mptr)(void)) {disconnectionCallChain.add(tptr, mptr);}
-private:
+public:
GapState_t getState(void) const {
return state;
}
@@ -334,17 +303,10 @@
}
public:
- 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) {
+ void processConnectionEvent(Handle_t handle, AddressType_t peerAddrType, const Address_t peerAddr, AddressType_t ownAddrType, const Address_t ownAddr, const ConnectionParams_t *params) {
state.connected = 1;
if (onConnection) {
- ConnectionCallbackParams_t callbackParams(handle, role, peerAddrType, peerAddr, ownAddrType, ownAddr, connectionParams);
- onConnection(&callbackParams);
+ onConnection(handle, peerAddrType, peerAddr, ownAddrType, ownAddr, params);
}
}
--- a/public/GapScanningParams.h Fri Jun 19 15:53:01 2015 +0100
+++ b/public/GapScanningParams.h Fri Jun 19 15:53:01 2015 +0100
@@ -80,7 +80,7 @@
_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; }
--- a/public/GattAttribute.h Fri Jun 19 15:53:01 2015 +0100
+++ b/public/GattAttribute.h Fri Jun 19 15:53:01 2015 +0100
@@ -17,8 +17,6 @@
#ifndef __GATT_ATTRIBUTE_H__
#define __GATT_ATTRIBUTE_H__
-#include "UUID.h"
-
class GattAttribute {
public:
typedef uint16_t Handle_t;
--- a/public/GattCallbackParamTypes.h Fri Jun 19 15:53:01 2015 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,78 +0,0 @@
-/* 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_CALLBACK_PARAM_TYPES_H__
-#define __GATT_CALLBACK_PARAM_TYPES_H__
-
-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 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 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. */
- AUTH_CALLBACK_REPLY_ATTERR_WRITE_NOT_PERMITTED = 0x0103, /**< ATT Error: Write not permitted. */
- AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHENTICATION = 0x0105, /**< ATT Error: Authenticated link required. */
- AUTH_CALLBACK_REPLY_ATTERR_INVALID_OFFSET = 0x0107, /**< ATT Error: Offset specified was past the end of the attribute. */
- AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHORIZATION = 0x0108, /**< ATT Error: Used in ATT as Insufficient Authorisation. */
- AUTH_CALLBACK_REPLY_ATTERR_PREPARE_QUEUE_FULL = 0x0109, /**< ATT Error: Used in ATT as Prepare Queue Full. */
- AUTH_CALLBACK_REPLY_ATTERR_ATTRIBUTE_NOT_FOUND = 0x010A, /**< ATT Error: Used in ATT as Attribute not found. */
- AUTH_CALLBACK_REPLY_ATTERR_ATTRIBUTE_NOT_LONG = 0x010B, /**< ATT Error: Attribute cannot be read or written using read/write blob requests. */
- AUTH_CALLBACK_REPLY_ATTERR_INVALID_ATT_VAL_LENGTH = 0x010D, /**< ATT Error: Invalid value size. */
- AUTH_CALLBACK_REPLY_ATTERR_INSUF_RESOURCES = 0x0111, /**< ATT Error: Encrypted link required. */
-};
-
-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. */
- 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 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. */
- 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_CALLBACK_PARAM_TYPES_H__*/
\ No newline at end of file
--- a/public/GattCharacteristic.h Fri Jun 19 15:53:01 2015 +0100
+++ b/public/GattCharacteristic.h Fri Jun 19 15:53:01 2015 +0100
@@ -19,7 +19,7 @@
#include "Gap.h"
#include "GattAttribute.h"
-#include "GattCallbackParamTypes.h"
+#include "GattCharacteristicCallbackParams.h"
#include "FunctionPointerWithContext.h"
class GattCharacteristic {
@@ -355,21 +355,21 @@
/**
* Authorization.
*/
- void setWriteAuthorizationCallback(void (*callback)(GattWriteAuthCallbackParams *)) {
+ void setWriteAuthorizationCallback(void (*callback)(GattCharacteristicWriteAuthCBParams *)) {
writeAuthorizationCallback.attach(callback);
enabledWriteAuthorization = true;
}
template <typename T>
- void setWriteAuthorizationCallback(T *object, void (T::*member)(GattWriteAuthCallbackParams *)) {
+ void setWriteAuthorizationCallback(T *object, void (T::*member)(GattCharacteristicWriteAuthCBParams *)) {
writeAuthorizationCallback.attach(object, member);
enabledWriteAuthorization = true;
}
- void setReadAuthorizationCallback(void (*callback)(GattReadAuthCallbackParams *)) {
+ void setReadAuthorizationCallback(void (*callback)(GattCharacteristicReadAuthCBParams *)) {
readAuthorizationCallback.attach(callback);
enabledReadAuthorization = true;
}
template <typename T>
- void setReadAuthorizationCallback(T *object, void (T::*member)(GattReadAuthCallbackParams *)) {
+ void setReadAuthorizationCallback(T *object, void (T::*member)(GattCharacteristicReadAuthCBParams *)) {
readAuthorizationCallback.attach(object, member);
enabledReadAuthorization = true;
}
@@ -380,7 +380,7 @@
* @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.
*/
- GattAuthCallbackReply_t authorizeWrite(GattWriteAuthCallbackParams *params) {
+ GattCharacteristicAuthCBReply_t authorizeWrite(GattCharacteristicWriteAuthCBParams *params) {
if (!isWriteAuthorizationEnabled()) {
return AUTH_CALLBACK_REPLY_SUCCESS;
}
@@ -406,7 +406,7 @@
*
* @return true if the read is authorized to proceed.
*/
- GattAuthCallbackReply_t authorizeRead(GattReadAuthCallbackParams *params) {
+ GattCharacteristicAuthCBReply_t authorizeRead(GattCharacteristicReadAuthCBParams *params) {
if (!isReadAuthorizationEnabled()) {
return AUTH_CALLBACK_REPLY_SUCCESS;
}
@@ -444,8 +444,8 @@
bool enabledReadAuthorization;
bool enabledWriteAuthorization;
- FunctionPointerWithContext<GattReadAuthCallbackParams *> readAuthorizationCallback;
- FunctionPointerWithContext<GattWriteAuthCallbackParams *> writeAuthorizationCallback;
+ FunctionPointerWithContext<GattCharacteristicReadAuthCBParams *> readAuthorizationCallback;
+ FunctionPointerWithContext<GattCharacteristicWriteAuthCBParams *> writeAuthorizationCallback;
private:
/* disallow copy and assignment */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/public/GattCharacteristicCallbackParams.h Fri Jun 19 15:53:01 2015 +0100
@@ -0,0 +1,80 @@
+/* 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_CHARACTERISTIC_CALLBACK_PARAMS_H__
+#define __GATT_CHARACTERISTIC_CALLBACK_PARAMS_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 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. */
+};
+
+enum GattCharacteristicAuthCBReply_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. */
+ AUTH_CALLBACK_REPLY_ATTERR_WRITE_NOT_PERMITTED = 0x0103, /**< ATT Error: Write not permitted. */
+ AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHENTICATION = 0x0105, /**< ATT Error: Authenticated link required. */
+ AUTH_CALLBACK_REPLY_ATTERR_INVALID_OFFSET = 0x0107, /**< ATT Error: Offset specified was past the end of the attribute. */
+ AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHORIZATION = 0x0108, /**< ATT Error: Used in ATT as Insufficient Authorisation. */
+ AUTH_CALLBACK_REPLY_ATTERR_PREPARE_QUEUE_FULL = 0x0109, /**< ATT Error: Used in ATT as Prepare Queue Full. */
+ AUTH_CALLBACK_REPLY_ATTERR_ATTRIBUTE_NOT_FOUND = 0x010A, /**< ATT Error: Used in ATT as Attribute not found. */
+ AUTH_CALLBACK_REPLY_ATTERR_ATTRIBUTE_NOT_LONG = 0x010B, /**< ATT Error: Attribute cannot be read or written using read/write blob requests. */
+ AUTH_CALLBACK_REPLY_ATTERR_INVALID_ATT_VAL_LENGTH = 0x010D, /**< ATT Error: Invalid value size. */
+ AUTH_CALLBACK_REPLY_ATTERR_INSUF_RESOURCES = 0x0111, /**< ATT Error: Encrypted link required. */
+};
+
+struct GattCharacteristicWriteAuthCBParams {
+ GattAttribute::Handle_t charHandle;
+ 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. */
+};
+
+struct GattCharacteristicReadAuthCBParams {
+ GattAttribute::Handle_t charHandle;
+ 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. */
+};
+
+#endif /*__GATT_CHARACTERISTIC_CALLBACK_PARAMS_H__*/
\ No newline at end of file
--- a/public/GattClient.h Fri Jun 19 15:53:01 2015 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,104 +0,0 @@
-/* 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__
\ No newline at end of file
--- a/public/GattServer.h Fri Jun 19 15:53:01 2015 +0100
+++ b/public/GattServer.h Fri Jun 19 15:53:01 2015 +0100
@@ -21,7 +21,7 @@
#include "GattService.h"
#include "GattAttribute.h"
#include "GattServerEvents.h"
-#include "GattCallbackParamTypes.h"
+#include "GattCharacteristicCallbackParams.h"
#include "CallChainOfFunctionPointersWithContext.h"
class GattServer {
@@ -43,8 +43,7 @@
/* empty */
}
- friend class BLEDevice;
-private:
+public:
/* These functions must be defined in the sub-class */
virtual ble_error_t addService(GattService &) = 0;
virtual ble_error_t readValue(GattAttribute::Handle_t attributeHandle, uint8_t buffer[], uint16_t *lengthP) = 0;
@@ -63,9 +62,9 @@
void setOnDataSent(T *objPtr, void (T::*memberPtr)(unsigned count)) {
onDataSent.add(objPtr, memberPtr);
}
- void setOnDataWritten(void (*callback)(const GattWriteCallbackParams *eventDataP)) {onDataWritten.add(callback);}
+ void setOnDataWritten(void (*callback)(const GattCharacteristicWriteCBParams *eventDataP)) {onDataWritten.add(callback);}
template <typename T>
- void setOnDataWritten(T *objPtr, void (T::*memberPtr)(const GattWriteCallbackParams *context)) {
+ void setOnDataWritten(T *objPtr, void (T::*memberPtr)(const GattCharacteristicWriteCBParams *context)) {
onDataWritten.add(objPtr, memberPtr);
}
@@ -76,7 +75,7 @@
virtual bool isOnDataReadAvailable() const {
return false;
}
- ble_error_t setOnDataRead(void (*callback)(const GattReadCallbackParams *eventDataP)) {
+ ble_error_t setOnDataRead(void (*callback)(const GattCharacteristicReadCBParams *eventDataP)) {
if (!isOnDataReadAvailable()) {
return BLE_ERROR_NOT_IMPLEMENTED;
}
@@ -85,7 +84,7 @@
return BLE_ERROR_NONE;
}
template <typename T>
- ble_error_t setOnDataRead(T *objPtr, void (T::*memberPtr)(const GattReadCallbackParams *context)) {
+ ble_error_t setOnDataRead(T *objPtr, void (T::*memberPtr)(const GattCharacteristicReadCBParams *context)) {
if (!isOnDataReadAvailable()) {
return BLE_ERROR_NOT_IMPLEMENTED;
}
@@ -98,13 +97,13 @@
void setOnConfirmationReceived(EventCallback_t callback) {onConfirmationReceived = callback;}
protected:
- void handleDataWrittenEvent(const GattWriteCallbackParams *params) {
+ void handleDataWrittenEvent(const GattCharacteristicWriteCBParams *params) {
if (onDataWritten.hasCallbacksAttached()) {
onDataWritten.call(params);
}
}
- void handleDataReadEvent(const GattReadCallbackParams *params) {
+ void handleDataReadEvent(const GattCharacteristicReadCBParams *params) {
if (onDataRead.hasCallbacksAttached()) {
onDataRead.call(params);
}
@@ -144,8 +143,8 @@
private:
CallChainOfFunctionPointersWithContext<unsigned> onDataSent;
- CallChainOfFunctionPointersWithContext<const GattWriteCallbackParams *> onDataWritten;
- CallChainOfFunctionPointersWithContext<const GattReadCallbackParams *> onDataRead;
+ CallChainOfFunctionPointersWithContext<const GattCharacteristicWriteCBParams *> onDataWritten;
+ CallChainOfFunctionPointersWithContext<const GattCharacteristicReadCBParams *> onDataRead;
EventCallback_t onUpdatesEnabled;
EventCallback_t onUpdatesDisabled;
EventCallback_t onConfirmationReceived;
--- a/public/ServiceDiscovery.h Fri Jun 19 15:53:01 2015 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,138 +0,0 @@
-/* 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__
\ No newline at end of file
--- a/public/UUID.h Fri Jun 19 15:53:01 2015 +0100
+++ b/public/UUID.h Fri Jun 19 15:53:01 2015 +0100
@@ -17,7 +17,6 @@
#ifndef __UUID_H__
#define __UUID_H__
-#include <stdint.h>
#include <string.h>
#include "blecommon.h"
@@ -29,10 +28,9 @@
UUID_TYPE_LONG = 1 // Full 128-bit UUID
};
- typedef uint16_t ShortUUIDBytes_t;
-
static const unsigned LENGTH_OF_LONG_UUID = 16;
- typedef uint8_t LongUUIDBytes_t[LENGTH_OF_LONG_UUID];
+ typedef uint16_t ShortUUIDBytes_t;
+ typedef uint8_t LongUUIDBytes_t[LENGTH_OF_LONG_UUID];
public:
/**
--- a/services/BatteryService.h Fri Jun 19 15:53:01 2015 +0100
+++ b/services/BatteryService.h Fri Jun 19 15:53:01 2015 +0100
@@ -38,16 +38,10 @@
batteryLevel(level),
batteryLevelCharacteristic(GattCharacteristic::UUID_BATTERY_LEVEL_CHAR, &batteryLevel, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY) {
- static bool serviceAdded = false; /* We should only ever need to add the heart rate service once. */
- if (serviceAdded) {
- return;
- }
-
GattCharacteristic *charTable[] = {&batteryLevelCharacteristic};
GattService batteryService(GattService::UUID_BATTERY_SERVICE, charTable, sizeof(charTable) / sizeof(GattCharacteristic *));
ble.addService(batteryService);
- serviceAdded = true;
}
/**
@@ -62,7 +56,7 @@
ble.updateCharacteristicValue(batteryLevelCharacteristic.getValueAttribute().getHandle(), &batteryLevel, 1);
}
-private:
+protected:
BLEDevice &ble;
uint8_t batteryLevel;
--- a/services/DFUService.h Fri Jun 19 15:53:01 2015 +0100
+++ b/services/DFUService.h Fri Jun 19 15:53:01 2015 +0100
@@ -54,11 +54,11 @@
*/
DFUService(BLEDevice &_ble, ResetPrepare_t _handoverCallback = NULL) :
ble(_ble),
- controlBytes(),
- packetBytes(),
controlPoint(DFUServiceControlCharacteristicUUID, controlBytes, GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY),
packet(DFUServicePacketCharacteristicUUID, packetBytes, SIZEOF_PACKET_BYTES, SIZEOF_PACKET_BYTES,
- GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE) {
+ GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE),
+ controlBytes(),
+ packetBytes() {
static bool serviceAdded = false; /* We should only ever need to add the DFU service once. */
if (serviceAdded) {
return;
@@ -94,8 +94,8 @@
* @param[in] params
* Information about the characterisitc being updated.
*/
- virtual void onDataWritten(const GattWriteCallbackParams *params) {
- if (params->handle == controlPoint.getValueHandle()) {
+ virtual void onDataWritten(const GattCharacteristicWriteCBParams *params) {
+ if (params->charHandle == controlPoint.getValueHandle()) {
/* At present, writing anything will do the trick--this needs to be improved. */
if (handoverCallback) {
handoverCallback();
@@ -105,16 +105,12 @@
}
}
-private:
+protected:
static const unsigned SIZEOF_CONTROL_BYTES = 2;
static const unsigned SIZEOF_PACKET_BYTES = 20;
- static ResetPrepare_t handoverCallback; /**< application specific handover callback. */
-
-private:
+protected:
BLEDevice &ble;
- uint8_t controlBytes[SIZEOF_CONTROL_BYTES];
- uint8_t packetBytes[SIZEOF_PACKET_BYTES];
/**< Writing to the control characteristic triggers the handover to dfu-
* bootloader. At present, writing anything will do the trick--this needs
@@ -127,6 +123,11 @@
* FOTA clients might get confused as service definitions change after
* handing control over to the bootloader. */
GattCharacteristic packet;
+
+ uint8_t controlBytes[SIZEOF_CONTROL_BYTES];
+ uint8_t packetBytes[SIZEOF_PACKET_BYTES];
+
+ static ResetPrepare_t handoverCallback; /**< application specific handover callback. */
};
#endif /* #ifndef __BLE_DFU_SERVICE_H__*/
\ No newline at end of file
--- a/services/DeviceInformationService.h Fri Jun 19 15:53:01 2015 +0100
+++ b/services/DeviceInformationService.h Fri Jun 19 15:53:01 2015 +0100
@@ -114,7 +114,7 @@
serviceAdded = true;
}
-private:
+protected:
BLEDevice &ble;
GattCharacteristic manufacturersNameStringCharacteristic;
GattCharacteristic modelNumberStringCharacteristic;
--- a/services/HeartRateService.h Fri Jun 19 15:53:01 2015 +0100
+++ b/services/HeartRateService.h Fri Jun 19 15:53:01 2015 +0100
@@ -114,7 +114,7 @@
* @param[in] params
* Information about the characterisitc being updated.
*/
- virtual void onDataWritten(const GattWriteCallbackParams *params) {
+ virtual void onDataWritten(const GattCharacteristicWriteCBParams *params) {
if (params->charHandle == controlPoint.getValueAttribute().getHandle()) {
/* Do something here if the new value is 1; else you can override this method by
* extending this class.
@@ -125,23 +125,16 @@
}
}
-private:
+protected:
void setupService(void) {
- static bool serviceAdded = false; /* We should only ever need to add the heart rate service once. */
- if (serviceAdded) {
- return;
- }
-
GattCharacteristic *charTable[] = {&hrmRate, &hrmLocation, &controlPoint};
GattService hrmService(GattService::UUID_HEART_RATE_SERVICE, charTable, sizeof(charTable) / sizeof(GattCharacteristic *));
ble.addService(hrmService);
- serviceAdded = true;
-
ble.onDataWritten(this, &HeartRateService::onDataWritten);
}
-private:
+protected:
/* Private internal representation for the bytes used to work with the vaulue of the heart-rate characteristic. */
struct HeartRateValueBytes {
static const unsigned MAX_VALUE_BYTES = 3; /* FLAGS + up to two bytes for heart-rate */
@@ -181,13 +174,13 @@
return 1 + ((valueBytes[FLAGS_BYTE_INDEX] & VALUE_FORMAT_FLAG) ? sizeof(uint16_t) : sizeof(uint8_t));
}
-private:
+ private:
/* First byte = 8-bit values, no extra info, Second byte = uint8_t HRM value */
/* See --> https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.heart_rate_measurement.xml */
uint8_t valueBytes[MAX_VALUE_BYTES];
};
-private:
+protected:
BLEDevice &ble;
HeartRateValueBytes valueBytes;
--- a/services/LinkLossService.h Fri Jun 19 15:53:01 2015 +0100
+++ b/services/LinkLossService.h Fri Jun 19 15:53:01 2015 +0100
@@ -80,7 +80,7 @@
* @param[in] params
* Information about the characterisitc being updated.
*/
- virtual void onDataWritten(const GattWriteCallbackParams *params) {
+ virtual void onDataWritten(const GattCharacteristicWriteCBParams *params) {
if (params->charHandle == alertLevelChar.getValueHandle()) {
alertLevel = *reinterpret_cast<const AlertLevel_t *>(params->data);
}
@@ -92,7 +92,7 @@
}
}
-private:
+protected:
BLEDevice &ble;
AlertLevel_t alertLevel;
callback_t callback;
--- a/services/UARTService.h Fri Jun 19 15:53:01 2015 +0100
+++ b/services/UARTService.h Fri Jun 19 15:53:01 2015 +0100
@@ -167,8 +167,8 @@
* function from the global onDataWritten() callback handler; or if that's
* not used, this method can be used as a callback directly.
*/
- void onDataWritten(const GattWriteCallbackParams *params) {
- if (params->handle == getTXCharacteristicHandle()) {
+ void onDataWritten(const GattCharacteristicWriteCBParams *params) {
+ if (params->charHandle == getTXCharacteristicHandle()) {
uint16_t bytesRead = params->len;
if (bytesRead <= BLE_UART_SERVICE_MAX_DATA_LEN) {
numBytesReceived = bytesRead;
--- a/services/URIBeaconConfigService.h Fri Jun 19 15:53:01 2015 +0100
+++ b/services/URIBeaconConfigService.h Fri Jun 19 15:53:01 2015 +0100
@@ -232,8 +232,8 @@
* characteristics of this service. Attempts to do so are also applied to
* the internal state of this service object.
*/
- void onDataWrittenCallback(const GattWriteCallbackParams *writeParams) {
- uint16_t handle = writeParams->handle;
+ void onDataWrittenCallback(const GattCharacteristicWriteCBParams *writeParams) {
+ uint16_t handle = writeParams->charHandle;
if (handle == lockChar.getValueHandle()) {
// Validated earlier
@@ -305,8 +305,8 @@
reinterpret_cast<uint8_t *>(params.advPowerLevels), sizeof(PowerLevels_t));
}
- private:
- void lockAuthorizationCallback(GattWriteAuthCallbackParams *authParams) {
+private:
+ void lockAuthorizationCallback(GattCharacteristicWriteAuthCBParams *authParams) {
if (lockedState) {
authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHORIZATION;
} else if (authParams->len != sizeof(Lock_t)) {
@@ -319,7 +319,7 @@
}
- void unlockAuthorizationCallback(GattWriteAuthCallbackParams *authParams) {
+ void unlockAuthorizationCallback(GattCharacteristicWriteAuthCBParams *authParams) {
if (!lockedState) {
authParams->authorizationReply = AUTH_CALLBACK_REPLY_SUCCESS;
} else if (authParams->len != sizeof(Lock_t)) {
@@ -333,7 +333,7 @@
}
}
- void uriDataWriteAuthorizationCallback(GattWriteAuthCallbackParams *authParams) {
+ void uriDataWriteAuthorizationCallback(GattCharacteristicWriteAuthCBParams *authParams) {
if (lockedState) {
authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHORIZATION;
} else if (authParams->offset != 0) {
@@ -343,7 +343,7 @@
}
}
- void powerModeAuthorizationCallback(GattWriteAuthCallbackParams *authParams) {
+ void powerModeAuthorizationCallback(GattCharacteristicWriteAuthCBParams *authParams) {
if (lockedState) {
authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHORIZATION;
} else if (authParams->len != sizeof(uint8_t)) {
@@ -358,7 +358,7 @@
}
template <typename T>
- void basicAuthorizationCallback(GattWriteAuthCallbackParams *authParams) {
+ void basicAuthorizationCallback(GattCharacteristicWriteAuthCBParams *authParams) {
if (lockedState) {
authParams->authorizationReply = AUTH_CALLBACK_REPLY_ATTERR_INSUF_AUTHORIZATION;
} else if (authParams->len != sizeof(T)) {
@@ -370,6 +370,7 @@
}
}
+protected:
BLEDevice &ble;
Params_t ¶ms;
@@ -391,7 +392,7 @@
ReadWriteGattCharacteristic<uint16_t> beaconPeriodChar;
WriteOnlyGattCharacteristic<uint8_t> resetChar;
- public:
+public:
/*
* Encode a human-readable URI into the binary format defined by URIBeacon spec (https://github.com/google/uribeacon/tree/master/specification).
*/