mirror of https://github.com/ARMmbed/mbed-os.git
332 lines
10 KiB
C
332 lines
10 KiB
C
|
/* 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 <stdint.h>
|
|||
|
|
#include <string.h>
|
|||
|
|
#include <algorithm>
|
|||
|
|
|
|||
|
|
#include "blecommon.h"
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* A trivial converter for single hexadecimal character to an unsigned integer.
|
|||
|
|
*
|
|||
|
|
* @param c
|
|||
|
|
* Hexadecimal character.
|
|||
|
|
*
|
|||
|
|
* @return The corresponding value as unsigned integer.
|
|||
|
|
*/
|
|||
|
|
static uint8_t char2int(char c) {
|
|||
|
|
if ((c >= '0') && (c <= '9')) {
|
|||
|
|
return c - '0';
|
|||
|
|
} else if ((c >= 'a') && (c <= 'f')) {
|
|||
|
|
return c - 'a' + 10;
|
|||
|
|
} else if ((c >= 'A') && (c <= 'F')) {
|
|||
|
|
return c - 'A' + 10;
|
|||
|
|
} else {
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* An instance of this class represents a Universally Unique Identifier (UUID)
|
|||
|
|
* in the BLE API.
|
|||
|
|
*/
|
|||
|
|
class UUID {
|
|||
|
|
public:
|
|||
|
|
/**
|
|||
|
|
* Enumeration of the possible types of UUIDs in BLE with regards to length.
|
|||
|
|
*/
|
|||
|
|
enum UUID_Type_t {
|
|||
|
|
UUID_TYPE_SHORT = 0, /**< Short 16-bit UUID. */
|
|||
|
|
UUID_TYPE_LONG = 1 /**< Full 128-bit UUID. */
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Enumeration to specify byte ordering of the long version of the UUID.
|
|||
|
|
*/
|
|||
|
|
typedef enum {
|
|||
|
|
MSB, /**< Most-significant byte first (at the smallest address) */
|
|||
|
|
LSB /**< least-significant byte first (at the smallest address) */
|
|||
|
|
} ByteOrder_t;
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Type for a 16-bit UUID.
|
|||
|
|
*/
|
|||
|
|
typedef uint16_t ShortUUIDBytes_t;
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Length of a long UUID in bytes.
|
|||
|
|
*/
|
|||
|
|
static const unsigned LENGTH_OF_LONG_UUID = 16;
|
|||
|
|
/**
|
|||
|
|
* Type for a 128-bit UUID.
|
|||
|
|
*/
|
|||
|
|
typedef uint8_t LongUUIDBytes_t[LENGTH_OF_LONG_UUID];
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Maximum length of a string representation of a UUID not including the
|
|||
|
|
* null termination ('\0'): two characters per
|
|||
|
|
* byte plus four '-' characters.
|
|||
|
|
*/
|
|||
|
|
static const unsigned MAX_UUID_STRING_LENGTH = LENGTH_OF_LONG_UUID * 2 + 4;
|
|||
|
|
|
|||
|
|
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 stringUUID
|
|||
|
|
* The 128-bit (16-byte) UUID as a human readable const-string.
|
|||
|
|
* Format: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
|
|||
|
|
* Upper and lower case supported. Hyphens are optional, but only
|
|||
|
|
* upto four of them. The UUID is stored internally as a 16 byte
|
|||
|
|
* array, LSB (little endian), which is opposite from the string.
|
|||
|
|
*/
|
|||
|
|
UUID(const char* stringUUID) : type(UUID_TYPE_LONG), baseUUID(), shortUUID(0) {
|
|||
|
|
bool nibble = false;
|
|||
|
|
uint8_t byte = 0;
|
|||
|
|
size_t baseIndex = 0;
|
|||
|
|
uint8_t tempUUID[LENGTH_OF_LONG_UUID];
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Iterate through string, abort if NULL is encountered prematurely.
|
|||
|
|
* Ignore upto four hyphens.
|
|||
|
|
*/
|
|||
|
|
for (size_t index = 0; (index < MAX_UUID_STRING_LENGTH) && (baseIndex < LENGTH_OF_LONG_UUID); index++) {
|
|||
|
|
if (stringUUID[index] == '\0') {
|
|||
|
|
/* Error abort */
|
|||
|
|
break;
|
|||
|
|
} else if (stringUUID[index] == '-') {
|
|||
|
|
/* Ignore hyphen */
|
|||
|
|
continue;
|
|||
|
|
} else if (nibble) {
|
|||
|
|
/* Got second nibble */
|
|||
|
|
byte |= char2int(stringUUID[index]);
|
|||
|
|
nibble = false;
|
|||
|
|
|
|||
|
|
/* Store copy */
|
|||
|
|
tempUUID[baseIndex++] = byte;
|
|||
|
|
} else {
|
|||
|
|
/* Got first nibble */
|
|||
|
|
byte = char2int(stringUUID[index]) << 4;
|
|||
|
|
nibble = true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Populate internal variables if string was successfully parsed */
|
|||
|
|
if (baseIndex == LENGTH_OF_LONG_UUID) {
|
|||
|
|
setupLong(tempUUID, UUID::MSB);
|
|||
|
|
} else {
|
|||
|
|
const uint8_t sig[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
|
|||
|
|
0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB };
|
|||
|
|
setupLong(sig, UUID::MSB);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Creates a new 128-bit UUID.
|
|||
|
|
*
|
|||
|
|
* @param[in] longUUID
|
|||
|
|
* The 128-bit (16-byte) UUID value.
|
|||
|
|
* @param[in] order
|
|||
|
|
* The bit order of the UUID, MSB by default.
|
|||
|
|
*
|
|||
|
|
* @note The UUID is a unique 128-bit (16 byte) ID used to identify
|
|||
|
|
* different service or characteristics on the BLE device.
|
|||
|
|
*/
|
|||
|
|
UUID(const LongUUIDBytes_t longUUID, ByteOrder_t order = UUID::MSB) : type(UUID_TYPE_LONG), baseUUID(), shortUUID(0) {
|
|||
|
|
setupLong(longUUID, order);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Creates a new 16-bit UUID.
|
|||
|
|
*
|
|||
|
|
* 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 (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
|
|||
|
|
*
|
|||
|
|
* @param[in] _shortUUID
|
|||
|
|
* The short UUID value.
|
|||
|
|
*
|
|||
|
|
* @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, you’ll need to use the full
|
|||
|
|
* 128-bit UUID value at all times.
|
|||
|
|
*
|
|||
|
|
* @note The UUID is a unique 16-bit (2 byte) ID used to identify
|
|||
|
|
* different service or characteristics on the BLE device.
|
|||
|
|
*
|
|||
|
|
* @note We do not yet support 32-bit shortened UUIDs.
|
|||
|
|
*/
|
|||
|
|
UUID(ShortUUIDBytes_t _shortUUID) : type(UUID_TYPE_SHORT), baseUUID(), shortUUID(_shortUUID) {
|
|||
|
|
/* Empty */
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Copy constructor.
|
|||
|
|
*
|
|||
|
|
* @param[in] source
|
|||
|
|
* The UUID to copy.
|
|||
|
|
*/
|
|||
|
|
UUID(const UUID &source) {
|
|||
|
|
type = source.type;
|
|||
|
|
shortUUID = source.shortUUID;
|
|||
|
|
memcpy(baseUUID, source.baseUUID, LENGTH_OF_LONG_UUID);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* The empty constructor.
|
|||
|
|
*
|
|||
|
|
* @note The type of the resulting UUID instance is UUID_TYPE_SHORT and the
|
|||
|
|
* value BLE_UUID_UNKNOWN.
|
|||
|
|
*/
|
|||
|
|
UUID(void) : type(UUID_TYPE_SHORT), shortUUID(BLE_UUID_UNKNOWN) {
|
|||
|
|
/* empty */
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Fill in a 128-bit UUID; this is useful when the UUID is not known at the
|
|||
|
|
* time of the object construction.
|
|||
|
|
*
|
|||
|
|
* @param[in] longUUID
|
|||
|
|
* The UUID value to copy.
|
|||
|
|
* @param[in] order
|
|||
|
|
* The byte ordering of the UUID at @p longUUID.
|
|||
|
|
*/
|
|||
|
|
void setupLong(const LongUUIDBytes_t longUUID, ByteOrder_t order = UUID::MSB) {
|
|||
|
|
type = UUID_TYPE_LONG;
|
|||
|
|
if (order == UUID::MSB) {
|
|||
|
|
/*
|
|||
|
|
* Switch endian. Input is big-endian, internal representation
|
|||
|
|
* is little endian.
|
|||
|
|
*/
|
|||
|
|
std::reverse_copy(longUUID, longUUID + LENGTH_OF_LONG_UUID, baseUUID);
|
|||
|
|
} else {
|
|||
|
|
std::copy(longUUID, longUUID + LENGTH_OF_LONG_UUID, baseUUID);
|
|||
|
|
}
|
|||
|
|
shortUUID = (uint16_t)((baseUUID[13] << 8) | (baseUUID[12]));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public:
|
|||
|
|
/**
|
|||
|
|
* Check whether this UUID is short or long.
|
|||
|
|
*
|
|||
|
|
* @return UUID_TYPE_SHORT if the UUID is short, UUID_TYPE_LONG otherwise.
|
|||
|
|
*/
|
|||
|
|
UUID_Type_t shortOrLong(void) const {
|
|||
|
|
return type;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Get a pointer to the UUID value based on the current UUID type.
|
|||
|
|
*
|
|||
|
|
* @return A pointer to the short UUID if the type is set to
|
|||
|
|
* UUID_TYPE_SHORT. Otherwise, a pointer to the long UUID if the
|
|||
|
|
* type is set to UUID_TYPE_LONG.
|
|||
|
|
*/
|
|||
|
|
const uint8_t *getBaseUUID(void) const {
|
|||
|
|
if (type == UUID_TYPE_SHORT) {
|
|||
|
|
return (const uint8_t*)&shortUUID;
|
|||
|
|
} else {
|
|||
|
|
return baseUUID;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Get the short UUID.
|
|||
|
|
*
|
|||
|
|
* @return The short UUID.
|
|||
|
|
*/
|
|||
|
|
ShortUUIDBytes_t getShortUUID(void) const {
|
|||
|
|
return shortUUID;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Get the length (in bytes) of the UUID based on its type.
|
|||
|
|
*
|
|||
|
|
* @retval sizeof(ShortUUIDBytes_t) if the UUID type is UUID_TYPE_SHORT.
|
|||
|
|
* @retval LENGTH_OF_LONG_UUID if the UUID type is UUID_TYPE_LONG.
|
|||
|
|
*/
|
|||
|
|
uint8_t getLen(void) const {
|
|||
|
|
return ((type == UUID_TYPE_SHORT) ? sizeof(ShortUUIDBytes_t) : LENGTH_OF_LONG_UUID);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Overload == operator to enable UUID comparisons.
|
|||
|
|
*
|
|||
|
|
* @param[in] other
|
|||
|
|
* The other UUID in the comparison.
|
|||
|
|
*
|
|||
|
|
* @return true if this == @p other, false otherwise.
|
|||
|
|
*/
|
|||
|
|
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;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* Overload != operator to enable UUID comparisons.
|
|||
|
|
*
|
|||
|
|
* @param[in] other
|
|||
|
|
* The other UUID in the comparison.
|
|||
|
|
*
|
|||
|
|
* @return true if this != @p other, false otherwise.
|
|||
|
|
*/
|
|||
|
|
bool operator!= (const UUID &other) const {
|
|||
|
|
return !(*this == other);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private:
|
|||
|
|
/**
|
|||
|
|
* The UUID type. Refer to UUID_Type_t.
|
|||
|
|
*/
|
|||
|
|
UUID_Type_t type;
|
|||
|
|
/**
|
|||
|
|
* The long UUID value.
|
|||
|
|
*/
|
|||
|
|
LongUUIDBytes_t baseUUID;
|
|||
|
|
/**
|
|||
|
|
* The short UUID value.
|
|||
|
|
*/
|
|||
|
|
ShortUUIDBytes_t shortUUID;
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
#endif // ifndef __UUID_H__
|