Release 0.3.8

=============

This is a minor set of enhancements before we yotta-ize BLE_API.

Enhancements
~~~~~~~~~~~~

* Minor rework for class UUID; added a default and copy constructor; and a != operator.

* Added copy constructor and accessors for GapAdvertisingParams.

* GapScanningParams:: remove unnecessary checks for SCAN_TIMEOUT_MAX.

* Add a comment header block to explain why BLEDevice::init() may not be safe
  to call from global static context.

* Introduce GattAttribute::INVALID_HANDLE.

* Replace some deprecated uses of Gap::address_t with Gap::Address_t.

Bugfixes
~~~~~~~~

* None.
This commit is contained in:
Rohit Grover 2015-06-08 10:28:33 +01:00
commit 7e8977d8e7
9 changed files with 219 additions and 167 deletions

View file

@ -33,8 +33,16 @@ public:
/**
* Initialize the BLE controller. This should be called before using
* anything else in the BLE_API.
*
* init() hands control to the underlying BLE module to accomplish
* initialization. This initialization may tacitly depend on other hardware
* 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().
*/
ble_error_t init();
ble_error_t reset(void);
/**
@ -48,13 +56,13 @@ public:
* Set the BTLE MAC address and type.
* @return BLE_ERROR_NONE on success.
*/
ble_error_t setAddress(Gap::addr_type_t type, const Gap::address_t address);
ble_error_t setAddress(Gap::AddressType_t type, const Gap::Address_t address);
/**
* Fetch the BTLE MAC address and type.
* @return BLE_ERROR_NONE on success.
*/
ble_error_t getAddress(Gap::addr_type_t *typeP, Gap::address_t address);
ble_error_t getAddress(Gap::AddressType_t *typeP, Gap::Address_t address);
/**
* @param[in] advType
@ -641,13 +649,13 @@ BLEDevice::shutdown(void)
}
inline ble_error_t
BLEDevice::setAddress(Gap::addr_type_t type, const Gap::address_t address)
BLEDevice::setAddress(Gap::AddressType_t type, const Gap::Address_t address)
{
return transport->getGap().setAddress(type, address);
}
inline ble_error_t
BLEDevice::getAddress(Gap::addr_type_t *typeP, Gap::address_t address)
BLEDevice::getAddress(Gap::AddressType_t *typeP, Gap::Address_t address)
{
return transport->getGap().getAddress(typeP, address);
}
@ -816,7 +824,6 @@ BLEDevice::setScanInterval(uint16_t interval) {
inline ble_error_t
BLEDevice::setScanWindow(uint16_t window) {
return scanningParams.setWindow(window);
}
@ -846,7 +853,6 @@ BLEDevice::stopScan(void) {
return transport->getGap().stopScan();
}
inline ble_error_t
BLEDevice::disconnect(Gap::DisconnectionReason_t reason)
{

View file

@ -62,10 +62,10 @@ public:
};
/* Describes the current state of the device (more than one bit can be set) */
typedef struct GapState_s {
struct GapState_t {
unsigned advertising : 1; /**< peripheral is currently advertising */
unsigned connected : 1; /**< peripheral is connected to a central */
} GapState_t;
};
typedef uint16_t Handle_t;
@ -142,8 +142,8 @@ public:
typedef void (*EventCallback_t)(void);
typedef void (*ConnectionEventCallback_t)(Handle_t,
addr_type_t peerAddrType, const Address_t peerAddr,
addr_type_t ownAddrType, const Address_t ownAddr,
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);
@ -167,8 +167,8 @@ public:
private:
/* These functions must be defined in the sub-class */
virtual ble_error_t setAddress(addr_type_t type, const Address_t address) = 0;
virtual ble_error_t getAddress(addr_type_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;
@ -299,7 +299,7 @@ protected:
}
public:
void processConnectionEvent(Handle_t handle, addr_type_t peerAddrType, const Address_t peerAddr, addr_type_t ownAddrType, const Address_t ownAddr, const ConnectionParams_t *params) {
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) {
onConnection(handle, peerAddrType, peerAddr, ownAddrType, ownAddr, params);

View file

@ -49,9 +49,6 @@ public:
if (_window > SCAN_WINDOW_MAX) {
_window = SCAN_WINDOW_MAX;
}
if (_timeout > SCAN_TIMEOUT_MAX) {
_timeout = SCAN_TIMEOUT_MAX;
}
}
ble_error_t setInterval(uint16_t newIntervalInMS) {
@ -75,12 +72,8 @@ public:
}
ble_error_t setTimeout(uint16_t newTimeout) {
if (newTimeout <= SCAN_TIMEOUT_MAX) {
_timeout = newTimeout;
return BLE_ERROR_NONE;
}
return BLE_ERROR_PARAM_OUT_OF_RANGE;
_timeout = newTimeout;
return BLE_ERROR_NONE;
}
void setActiveScanning(bool activeScanning) {

View file

@ -20,6 +20,7 @@
class GattAttribute {
public:
typedef uint16_t Handle_t;
static const Handle_t INVALID_HANDLE = 0x0000;
public:
/**

View file

@ -1,119 +1,141 @@
/* 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 __UUID_H__
#define __UUID_H__
#include <string.h>
#include "blecommon.h"
const unsigned LENGTH_OF_LONG_UUID = 16;
typedef uint16_t ShortUUIDBytes_t;
typedef uint8_t LongUUIDBytes_t[LENGTH_OF_LONG_UUID];
class UUID {
public:
enum UUID_Type_t {
UUID_TYPE_SHORT = 0, // Short BLE UUID
UUID_TYPE_LONG = 1 // Full 128-bit UUID
};
public:
/**
* Creates a new 128-bit UUID
*
* @note The UUID is a unique 128-bit (16 byte) ID used to identify
* different service or characteristics on the BLE device.
*
* @param longUUID
* The 128-bit (16-byte) UUID value.
*/
UUID(const LongUUIDBytes_t longUUID) : type(UUID_TYPE_LONG), baseUUID(), shortUUID(0) {
memcpy(baseUUID, longUUID, LENGTH_OF_LONG_UUID);
shortUUID = (uint16_t)((longUUID[2] << 8) | (longUUID[3]));
}
/**
* Creates a new 16-bit UUID
*
* @note The UUID is a unique 16-bit (2 byte) ID used to identify
* different service or characteristics on the BLE device.
*
* For efficiency, and because 16 bytes would take a large chunk of the
* 27-byte data payload length of the Link Layer, the BLE specification adds
* two additional UUID formats: 16-bit and 32-bit UUIDs. These shortened
* formats can be used only with UUIDs that are defined in the Bluetooth
* specification (i.e., that are listed by the Bluetooth SIG as standard
* Bluetooth UUIDs).
*
* To reconstruct the full 128-bit UUID from the shortened version, insert
* the 16-bit short value (indicated by xxxx, including leading zeros) into
* the Bluetooth Base UUID:
*
* 0000xxxx-0000-1000-8000-00805F9B34FB
*
* @note Shortening is not available for UUIDs that are not derived from the
* Bluetooth Base UUID. Such non-standard UUIDs are commonly called
* vendor-specific UUIDs. In these cases, youll need to use the full
* 128-bit UUID value at all times.
*
* @note we don't yet support 32-bit shortened UUIDs.
*/
UUID(ShortUUIDBytes_t shortUUID) : type(UUID_TYPE_SHORT), baseUUID(), shortUUID(shortUUID) {
/* empty */
}
public:
UUID_Type_t shortOrLong(void) const {return type; }
const uint8_t *getBaseUUID(void) const {
if (type == UUID_TYPE_SHORT) {
return (const uint8_t*)&shortUUID;
} else {
return baseUUID;
}
}
ShortUUIDBytes_t getShortUUID(void) const {return shortUUID;}
uint8_t getLen(void) const {
return ((type == UUID_TYPE_SHORT) ? sizeof(ShortUUIDBytes_t) : LENGTH_OF_LONG_UUID);
}
bool operator== (const UUID &other) const {
if ((this->type == UUID_TYPE_SHORT) && (other.type == UUID_TYPE_SHORT) &&
(this->shortUUID == other.shortUUID)) {
return true;
}
if ((this->type == UUID_TYPE_LONG) && (other.type == UUID_TYPE_LONG) &&
(memcmp(this->baseUUID, other.baseUUID, LENGTH_OF_LONG_UUID) == 0)) {
return true;
}
return false;
}
private:
UUID_Type_t type; // UUID_TYPE_SHORT or UUID_TYPE_LONG
LongUUIDBytes_t baseUUID; /* the base of the long UUID (if
* used). Note: bytes 12 and 13 (counting from LSB)
* are zeroed out to allow comparison with other long
* UUIDs which differ only in the 16-bit relative
* part.*/
ShortUUIDBytes_t shortUUID; // 16 bit uuid (byte 2-3 using with base)
};
#endif // ifndef __UUID_H__
/* 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 __UUID_H__
#define __UUID_H__
#include <string.h>
#include "blecommon.h"
class UUID {
public:
enum UUID_Type_t {
UUID_TYPE_SHORT = 0, // Short BLE UUID
UUID_TYPE_LONG = 1 // Full 128-bit UUID
};
static const unsigned LENGTH_OF_LONG_UUID = 16;
typedef uint16_t ShortUUIDBytes_t;
typedef uint8_t LongUUIDBytes_t[LENGTH_OF_LONG_UUID];
public:
/**
* Creates a new 128-bit UUID
*
* @note The UUID is a unique 128-bit (16 byte) ID used to identify
* different service or characteristics on the BLE device.
*
* @param longUUID
* The 128-bit (16-byte) UUID value, MSB first (big-endian).
*/
UUID(const LongUUIDBytes_t longUUID) : type(UUID_TYPE_LONG), baseUUID(), shortUUID(0) {
setupLong(longUUID);
}
/**
* Creates a new 16-bit UUID
*
* @note The UUID is a unique 16-bit (2 byte) ID used to identify
* different service or characteristics on the BLE device.
*
* For efficiency, and because 16 bytes would take a large chunk of the
* 27-byte data payload length of the Link Layer, the BLE specification adds
* two additional UUID formats: 16-bit and 32-bit UUIDs. These shortened
* formats can be used only with UUIDs that are defined in the Bluetooth
* specification (i.e., that are listed by the Bluetooth SIG as standard
* Bluetooth UUIDs).
*
* To reconstruct the full 128-bit UUID from the shortened version, insert
* the 16-bit short value (indicated by xxxx, including leading zeros) into
* the Bluetooth Base UUID:
*
* 0000xxxx-0000-1000-8000-00805F9B34FB
*
* @note Shortening is not available for UUIDs that are not derived from the
* Bluetooth Base UUID. Such non-standard UUIDs are commonly called
* vendor-specific UUIDs. In these cases, youll need to use the full
* 128-bit UUID value at all times.
*
* @note we don't yet support 32-bit shortened UUIDs.
*/
UUID(ShortUUIDBytes_t shortUUID) : type(UUID_TYPE_SHORT), baseUUID(), shortUUID(shortUUID) {
/* empty */
}
UUID(const UUID &source) {
type = source.type;
shortUUID = source.shortUUID;
memcpy(baseUUID, source.baseUUID, LENGTH_OF_LONG_UUID);
}
UUID(void) : type(UUID_TYPE_SHORT), shortUUID(BLE_UUID_UNKNOWN) {
/* empty */
}
/**
* Fill in a 128-bit UUID; this is useful when UUID isn't known at the time of object construction.
*/
void setupLong(const LongUUIDBytes_t longUUID) {
type = UUID_TYPE_LONG;
memcpy(baseUUID, longUUID, LENGTH_OF_LONG_UUID);
shortUUID = (uint16_t)((longUUID[2] << 8) | (longUUID[3]));
}
public:
UUID_Type_t shortOrLong(void) const {return type; }
const uint8_t *getBaseUUID(void) const {
if (type == UUID_TYPE_SHORT) {
return (const uint8_t*)&shortUUID;
} else {
return baseUUID;
}
}
ShortUUIDBytes_t getShortUUID(void) const {return shortUUID;}
uint8_t getLen(void) const {
return ((type == UUID_TYPE_SHORT) ? sizeof(ShortUUIDBytes_t) : LENGTH_OF_LONG_UUID);
}
bool operator== (const UUID &other) const {
if ((this->type == UUID_TYPE_SHORT) && (other.type == UUID_TYPE_SHORT) &&
(this->shortUUID == other.shortUUID)) {
return true;
}
if ((this->type == UUID_TYPE_LONG) && (other.type == UUID_TYPE_LONG) &&
(memcmp(this->baseUUID, other.baseUUID, LENGTH_OF_LONG_UUID) == 0)) {
return true;
}
return false;
}
bool operator!= (const UUID &other) const {
return !(*this == other);
}
private:
UUID_Type_t type; // UUID_TYPE_SHORT or UUID_TYPE_LONG
LongUUIDBytes_t baseUUID; /* the base of the long UUID (if
* used). Note: bytes 12 and 13 (counting from LSB)
* are zeroed out to allow comparison with other long
* UUIDs which differ only in the 16-bit relative
* part.*/
ShortUUIDBytes_t shortUUID; // 16 bit uuid (byte 2-3 using with base)
};
#endif // ifndef __UUID_H__

View file

@ -16,26 +16,26 @@
#include "UARTService.h"
const uint8_t UARTServiceBaseUUID[LENGTH_OF_LONG_UUID] = {
const uint8_t UARTServiceBaseUUID[UUID::LENGTH_OF_LONG_UUID] = {
0x6E, 0x40, 0x00, 0x00, 0xB5, 0xA3, 0xF3, 0x93,
0xE0, 0xA9, 0xE5, 0x0E, 0x24, 0xDC, 0xCA, 0x9E,
};
const uint16_t UARTServiceShortUUID = 0x0001;
const uint16_t UARTServiceTXCharacteristicShortUUID = 0x0002;
const uint16_t UARTServiceRXCharacteristicShortUUID = 0x0003;
const uint8_t UARTServiceUUID[LENGTH_OF_LONG_UUID] = {
const uint8_t UARTServiceUUID[UUID::LENGTH_OF_LONG_UUID] = {
0x6E, 0x40, (uint8_t)(UARTServiceShortUUID >> 8), (uint8_t)(UARTServiceShortUUID & 0xFF), 0xB5, 0xA3, 0xF3, 0x93,
0xE0, 0xA9, 0xE5, 0x0E, 0x24, 0xDC, 0xCA, 0x9E,
};
const uint8_t UARTServiceUUID_reversed[LENGTH_OF_LONG_UUID] = {
const uint8_t UARTServiceUUID_reversed[UUID::LENGTH_OF_LONG_UUID] = {
0x9E, 0xCA, 0xDC, 0x24, 0x0E, 0xE5, 0xA9, 0xE0,
0x93, 0xF3, 0xA3, 0xB5, (uint8_t)(UARTServiceShortUUID & 0xFF), (uint8_t)(UARTServiceShortUUID >> 8), 0x40, 0x6E
};
const uint8_t UARTServiceTXCharacteristicUUID[LENGTH_OF_LONG_UUID] = {
const uint8_t UARTServiceTXCharacteristicUUID[UUID::LENGTH_OF_LONG_UUID] = {
0x6E, 0x40, (uint8_t)(UARTServiceTXCharacteristicShortUUID >> 8), (uint8_t)(UARTServiceTXCharacteristicShortUUID & 0xFF), 0xB5, 0xA3, 0xF3, 0x93,
0xE0, 0xA9, 0xE5, 0x0E, 0x24, 0xDC, 0xCA, 0x9E,
};
const uint8_t UARTServiceRXCharacteristicUUID[LENGTH_OF_LONG_UUID] = {
const uint8_t UARTServiceRXCharacteristicUUID[UUID::LENGTH_OF_LONG_UUID] = {
0x6E, 0x40, (uint8_t)(UARTServiceRXCharacteristicShortUUID >> 8), (uint8_t)(UARTServiceRXCharacteristicShortUUID & 0xFF), 0xB5, 0xA3, 0xF3, 0x93,
0xE0, 0xA9, 0xE5, 0x0E, 0x24, 0xDC, 0xCA, 0x9E,
};

View file

@ -23,16 +23,16 @@
#include "UUID.h"
#include "BLEDevice.h"
extern const uint8_t UARTServiceBaseUUID[LENGTH_OF_LONG_UUID];
extern const uint8_t UARTServiceBaseUUID[UUID::LENGTH_OF_LONG_UUID];
extern const uint16_t UARTServiceShortUUID;
extern const uint16_t UARTServiceTXCharacteristicShortUUID;
extern const uint16_t UARTServiceRXCharacteristicShortUUID;
extern const uint8_t UARTServiceUUID[LENGTH_OF_LONG_UUID];
extern const uint8_t UARTServiceUUID_reversed[LENGTH_OF_LONG_UUID];
extern const uint8_t UARTServiceUUID[UUID::LENGTH_OF_LONG_UUID];
extern const uint8_t UARTServiceUUID_reversed[UUID::LENGTH_OF_LONG_UUID];
extern const uint8_t UARTServiceTXCharacteristicUUID[LENGTH_OF_LONG_UUID];
extern const uint8_t UARTServiceRXCharacteristicUUID[LENGTH_OF_LONG_UUID];
extern const uint8_t UARTServiceTXCharacteristicUUID[UUID::LENGTH_OF_LONG_UUID];
extern const uint8_t UARTServiceRXCharacteristicUUID[UUID::LENGTH_OF_LONG_UUID];
/**
* @class UARTService

View file

@ -0,0 +1,35 @@
/* 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 "URIBeaconConfigService.h"
#define UUID_URI_BEACON(FIRST, SECOND) { \
0xee, 0x0c, FIRST, SECOND, 0x87, 0x86, 0x40, 0xba, \
0xab, 0x96, 0x99, 0xb9, 0x1a, 0xc9, 0x81, 0xd8, \
}
const uint8_t UUID_URI_BEACON_SERVICE[LENGTH_OF_LONG_UUID] = UUID_URI_BEACON(0x20, 0x80);
const uint8_t UUID_LOCK_STATE_CHAR[LENGTH_OF_LONG_UUID] = UUID_URI_BEACON(0x20, 0x81);
const uint8_t UUID_LOCK_CHAR[LENGTH_OF_LONG_UUID] = UUID_URI_BEACON(0x20, 0x82);
const uint8_t UUID_UNLOCK_CHAR[LENGTH_OF_LONG_UUID] = UUID_URI_BEACON(0x20, 0x83);
const uint8_t UUID_URI_DATA_CHAR[LENGTH_OF_LONG_UUID] = UUID_URI_BEACON(0x20, 0x84);
const uint8_t UUID_FLAGS_CHAR[LENGTH_OF_LONG_UUID] = UUID_URI_BEACON(0x20, 0x85);
const uint8_t UUID_ADV_POWER_LEVELS_CHAR[LENGTH_OF_LONG_UUID] = UUID_URI_BEACON(0x20, 0x86);
const uint8_t UUID_TX_POWER_MODE_CHAR[LENGTH_OF_LONG_UUID] = UUID_URI_BEACON(0x20, 0x87);
const uint8_t UUID_BEACON_PERIOD_CHAR[LENGTH_OF_LONG_UUID] = UUID_URI_BEACON(0x20, 0x88);
const uint8_t UUID_RESET_CHAR[LENGTH_OF_LONG_UUID] = UUID_URI_BEACON(0x20, 0x89);
const uint8_t BEACON_UUID[sizeof(ShortUUIDBytes_t)] = {0xD8, 0xFE};

View file

@ -20,23 +20,18 @@
#include "BLEDevice.h"
#include "mbed.h"
#define UUID_URI_BEACON(FIRST, SECOND) { \
0xee, 0x0c, FIRST, SECOND, 0x87, 0x86, 0x40, 0xba, \
0xab, 0x96, 0x99, 0xb9, 0x1a, 0xc9, 0x81, 0xd8, \
}
extern const uint8_t UUID_URI_BEACON_SERVICE[LENGTH_OF_LONG_UUID];
extern const uint8_t UUID_LOCK_STATE_CHAR[LENGTH_OF_LONG_UUID];
extern const uint8_t UUID_LOCK_CHAR[LENGTH_OF_LONG_UUID];
extern const uint8_t UUID_UNLOCK_CHAR[LENGTH_OF_LONG_UUID];
extern const uint8_t UUID_URI_DATA_CHAR[LENGTH_OF_LONG_UUID];
extern const uint8_t UUID_FLAGS_CHAR[LENGTH_OF_LONG_UUID];
extern const uint8_t UUID_ADV_POWER_LEVELS_CHAR[LENGTH_OF_LONG_UUID];
extern const uint8_t UUID_TX_POWER_MODE_CHAR[LENGTH_OF_LONG_UUID];
extern const uint8_t UUID_BEACON_PERIOD_CHAR[LENGTH_OF_LONG_UUID];
extern const uint8_t UUID_RESET_CHAR[LENGTH_OF_LONG_UUID];
static const uint8_t UUID_URI_BEACON_SERVICE[] = UUID_URI_BEACON(0x20, 0x80);
static const uint8_t UUID_LOCK_STATE_CHAR[] = UUID_URI_BEACON(0x20, 0x81);
static const uint8_t UUID_LOCK_CHAR[] = UUID_URI_BEACON(0x20, 0x82);
static const uint8_t UUID_UNLOCK_CHAR[] = UUID_URI_BEACON(0x20, 0x83);
static const uint8_t UUID_URI_DATA_CHAR[] = UUID_URI_BEACON(0x20, 0x84);
static const uint8_t UUID_FLAGS_CHAR[] = UUID_URI_BEACON(0x20, 0x85);
static const uint8_t UUID_ADV_POWER_LEVELS_CHAR[] = UUID_URI_BEACON(0x20, 0x86);
static const uint8_t UUID_TX_POWER_MODE_CHAR[] = UUID_URI_BEACON(0x20, 0x87);
static const uint8_t UUID_BEACON_PERIOD_CHAR[] = UUID_URI_BEACON(0x20, 0x88);
static const uint8_t UUID_RESET_CHAR[] = UUID_URI_BEACON(0x20, 0x89);
static const uint8_t BEACON_UUID[] = {0xD8, 0xFE};
extern const uint8_t BEACON_UUID[sizeof(ShortUUIDBytes_t)];
/**
* @class URIBeaconConfigService