BLEUUID Class Reference

A model of a BLE UUID. More...

#include <BLEUUID.hpp>

Public Member Functions
	BLEUUID (std::string uuid)
	BLEUUID (uint16_t uuid)
	Create a UUID from the 16bit value. More...
	BLEUUID (uint32_t uuid)
	Create a UUID from the 32bit value. More...
	BLEUUID (uint8_t *pData, size_t size, bool msbFirst)
	Create a UUID from 16 bytes of memory. More...
uint8_t	bitSize ()
	Get the number of bits in this uuid. More...
bool	equals (BLEUUID uuid)
	Compare a UUID against this UUID. More...
BLEUUID	to128 ()
	Convert a UUID to its 128 bit representation. More...
std::string	toString ()
	Get a string representation of the UUID. More...
bool	operator== (uint16_t other) const
bool	operator== (uint32_t other) const

Static Public Member Functions
static BLEUUID	fromString (std::string uuid)

Public Attributes
uint16_t	len
union {
uint16_t   raw16
uint32_t   raw32
uint8_t   raw128 [16]
};

Detailed Description

A model of a BLE UUID.

Constructor & Destructor Documentation

BLEUUID() [1/3]

BLEUUID::BLEUUID

(

uint16_t

uuid

)

Create a UUID from the 16bit value.

Parameters

[in]

uuid

The 16bit short form UUID.

                              {
    this->len          = 2;
    this->raw16        = uuid;
    m_valueSet         = true;
} // BLEUUID

BLEUUID() [2/3]

BLEUUID::BLEUUID

(

uint32_t

uuid

)

Create a UUID from the 32bit value.

Parameters

[in]

uuid

The 32bit short form UUID.

                              {
    this->len          = 4;
    this->raw32        = uuid;
    m_valueSet         = true;
} // BLEUUID

BLEUUID() [3/3]

BLEUUID::BLEUUID	(	uint8_t *	pData,
		size_t	size,
		bool	msbFirst
	)

Create a UUID from 16 bytes of memory.

Parameters

[in]	pData	The pointer to the start of the UUID.
[in]	size	The size of the data.
[in]	msbFirst	Is the MSB first in pData memory?

                                                           {
    if (size != 16) {
        _debug_print(TAG, "ERROR: UUID length not 16 bytes");
        return;
    }
    this->len = 16;
    if (msbFirst) {
        memrcpy(this->raw128, pData, 16);
    } else {
        memcpy(this->raw128, pData, 16);
    }
    m_valueSet         = true;
} // BLEUUID

Member Function Documentation

bitSize()

uint8_t BLEUUID::bitSize

(

)

Get the number of bits in this uuid.

Returns

The number of bits in the UUID. One of 16, 32 or 128.

                         {
    if (!m_valueSet) return 0;
    switch(this->len) {
        case 2:
            return 16;
        case 4:
            return 32;
        case 16:
            return 128;
        default:
            _debug_print_d(TAG, "Unknown UUID length", len);
            return 0;
    } // End of switch
} // bitSize

equals()

bool BLEUUID::equals

(

BLEUUID

uuid

)

Compare a UUID against this UUID.

Parameters

[in]

uuid

The UUID to compare against.

Returns

True if the UUIDs are equal and false otherwise.

                                 {
    if (m_valueSet == false || uuid.m_valueSet == false) {
        return false;
    }
 
    if (uuid.len != len) {
        return uuid.toString() == toString();
    }
 
    if (uuid.len == 2) {
        return uuid.raw16 == raw16;
    }
 
    if (uuid.len == 4) {
        return uuid.raw32 == raw32;
    }
 
    return memcmp(uuid.raw128, raw128, 16) == 0;
} // equals

fromString()

BLEUUID BLEUUID::fromString ( std::string  _uuid )

static

Create a BLEUUID from a string of the form: 0xNNNN 0xNNNNNNNN 0x<UUID> NNNN NNNNNNNN <UUID>

                                           {
    uint8_t start = 0;
    if (strstr(_uuid.c_str(), "0x") != nullptr) { // If the string starts with 0x, skip those characters.
        start = 2;
    }
    uint8_t len = _uuid.length() - start; // Calculate the length of the string we are going to use.
 
    if(len == 4) {
        uint16_t x = strtoul(_uuid.substr(start, len).c_str(), NULL, 16);
        return BLEUUID(x);
    } else if (len == 8) {
        uint32_t x = strtoul(_uuid.substr(start, len).c_str(), NULL, 16);
        return BLEUUID(x);
    } else if (len == 36) {
        return BLEUUID(_uuid);
    }
    return BLEUUID();
} // fromString

to128()

BLEUUID BLEUUID::to128

(

)

Convert a UUID to its 128 bit representation.

A UUID can be internally represented as 16bit, 32bit or the full 128bit. This method will convert 16 or 32 bit representations to the full 128bit.

                       {
    //_debug_print_s(TAG, ">> toFull()", toString().c_str());
 
    // If we either don't have a value or are already a 128 bit UUID, nothing further to do.
    if (!m_valueSet || this->len == 16) {
        return *this;
    }
 
    // If we are 16 bit or 32 bit, then set the 4 bytes of the variable part of the UUID.
    if (this->len == 2) {
        uint16_t temp = this->raw16;
        this->raw128[15] = 0;
        this->raw128[14] = 0;
        this->raw128[13] = (temp >> 8) & 0xff;
        this->raw128[12] = temp & 0xff;
 
    }
    else if (this->len == 4) {
        uint32_t temp = this->raw32;
        this->raw128[15] = (temp >> 24) & 0xff;
        this->raw128[14] = (temp >> 16) & 0xff;
        this->raw128[13] = (temp >> 8) & 0xff;
        this->raw128[12] = temp & 0xff;
    }
 
    // Set the fixed parts of the UUID.
    this->raw128[11] = 0x00;
    this->raw128[10] = 0x00;
 
    this->raw128[9]  = 0x10;
    this->raw128[8]  = 0x00;
 
    this->raw128[7]  = 0x80;
    this->raw128[6]  = 0x00;
 
    this->raw128[5]  = 0x00;
    this->raw128[4]  = 0x80;
    this->raw128[3]  = 0x5f;
    this->raw128[2]  = 0x9b;
    this->raw128[1]  = 0x34;
    this->raw128[0]  = 0xfb;
 
    this->len = 16;
    //_debug_print_s(TAG, "<< toFull", toString().c_str());
    return *this;
} // to128

toString()

std::string BLEUUID::toString

(

)

Get a string representation of the UUID.

The format of a string is: 01234567 8901 2345 6789 012345678901 0000180d-0000-1000-8000-00805f9b34fb 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5

Returns

A string representation of the UUID.

                            {
    if (!m_valueSet) return "<NULL>";   // If we have no value, nothing to format.
 
    // If the UUIDs are 16 or 32 bit, pad correctly.
    std::stringstream ss;
 
    if (this->len == 2) {  // If the UUID is 16bit, pad correctly.
        ss << "0000" <<
            std::hex <<
            std::setfill('0') <<
            std::setw(4) <<
            this->raw16 <<
            "-0000-1000-8000-00805f9b34fb";
        return ss.str();                    // Return the string
    } // End 16bit UUID
 
    if (this->len == 4) {  // If the UUID is 32bit, pad correctly.
        ss << std::hex <<
            std::setfill('0') <<
            std::setw(8) <<
            this->raw32 <<
            "-0000-1000-8000-00805f9b34fb";
        return ss.str();                    // return the string
    } // End 32bit UUID
 
    // The UUID is not 16bit or 32bit which means that it is 128bit.
    //
    // UUID string format:
    // AABBCCDD-EEFF-GGHH-IIJJ-KKLLMMNNOOPP
    //
    ss << std::hex << std::setfill('0') <<
        std::setw(2) << (int)raw128[15] <<
        std::setw(2) << (int)raw128[14] <<
        std::setw(2) << (int)raw128[13] <<
        std::setw(2) << (int)raw128[12] << "-" <<
        std::setw(2) << (int)raw128[11] <<
        std::setw(2) << (int)raw128[10] << "-" <<
        std::setw(2) << (int)raw128[9]  <<
        std::setw(2) << (int)raw128[8]  << "-" <<
        std::setw(2) << (int)raw128[7]  <<
        std::setw(2) << (int)raw128[6]  << "-" <<
        std::setw(2) << (int)raw128[5]  <<
        std::setw(2) << (int)raw128[4]  <<
        std::setw(2) << (int)raw128[3]  <<
        std::setw(2) << (int)raw128[2]  <<
        std::setw(2) << (int)raw128[1]  <<
        std::setw(2) << (int)raw128[0];
    return ss.str();
} // toString

---

The documentation for this class was generated from the following files:

• nola-sdk/include/BLEUUID.hpp
• src/net/BluetoothLE/BLEUUID.cpp