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

improve the constructor for GattCharacteristic to make better use of default arguments

Browse source
This commit is contained in:
Rohit Grover 2014-06-11 10:32:08 +01:00
commit 95aacbbb53
15 changed files with 2470 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

238
GapAdvertisingData.cpp Normal file
View file

@ -0,0 +1,238 @@
/* 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 <stdio.h>
#include <string.h>
#include "GapAdvertisingData.h"
/**************************************************************************/
/*!
\brief Creates a new GapAdvertisingData instance
\par EXAMPLE
\code
\endcode
*/
/**************************************************************************/
GapAdvertisingData::GapAdvertisingData(void) : _payload(), _payloadLen(0), _appearance(GENERIC_TAG) {
/* empty */
}
/**************************************************************************/
/*!
Destructor
*/
/**************************************************************************/
GapAdvertisingData::~GapAdvertisingData(void)
{
}
/**************************************************************************/
/*!
\brief Adds advertising data based on the specified AD type (see
DataType)
\args[in] advDataType The Advertising 'DataType' to add
\args[in] payload Pointer to the payload contents
\args[in] len Size of the payload in bytes
\returns ble_error_t
\retval BLE_ERROR_NONE
Everything executed properly
\retval BLE_ERROR_BUFFER_OVERFLOW
The specified data would cause the advertising buffer
to overflow
\par EXAMPLE
\code
\endcode
*/
/**************************************************************************/
ble_error_t GapAdvertisingData::addData(DataType advDataType, const uint8_t *payload, uint8_t len)
{
/* ToDo: Check if an AD type already exists and if the existing */
/* value is exclusive or not (flags, etc.) */
/* Make sure we don't exceed the 31 byte payload limit */
if (_payloadLen + len + 2 > GAP_ADVERTISING_DATA_MAX_PAYLOAD) {
return BLE_ERROR_BUFFER_OVERFLOW;
}
/* Field length */
memset(&_payload[_payloadLen], len + 1, 1);
_payloadLen++;
/* Field ID */
memset(&_payload[_payloadLen], (uint8_t)advDataType, 1);
_payloadLen++;
/* Payload */
memcpy(&_payload[_payloadLen], payload, len);
_payloadLen += len;
return BLE_ERROR_NONE;
}
/**************************************************************************/
/*!
\brief Helper function to add APPEARANCE data to the advertising
payload
\args[in] appearance The APPEARANCE value to add
\returns ble_error_t
\retval BLE_ERROR_NONE
Everything executed properly
\retval BLE_ERROR_BUFFER_OVERFLOW
The specified data would cause the advertising buffer
to overflow
\par EXAMPLE
\code
\endcode
*/
/**************************************************************************/
ble_error_t GapAdvertisingData::addAppearance(Appearance appearance)
{
_appearance = appearance;
return addData(GapAdvertisingData::APPEARANCE, (uint8_t *)&appearance, 2);
}
/**************************************************************************/
/*!
\brief Helper function to add FLAGS data to the advertising
payload
\args[in] flag The FLAGS value to add
\par LE_LIMITED_DISCOVERABLE
The peripheral is discoverable for a limited period of
time
\par LE_GENERAL_DISCOVERABLE
The peripheral is permanently discoverable
\par BREDR_NOT_SUPPORTED
This peripheral is a Bluetooth Low Energy only device
(no EDR support)
\returns ble_error_t
\retval BLE_ERROR_NONE
Everything executed properly
\retval BLE_ERROR_BUFFER_OVERFLOW
The specified data would cause the advertising buffer
to overflow
\par EXAMPLE
\code
\endcode
*/
/**************************************************************************/
ble_error_t GapAdvertisingData::addFlags(Flags flag)
{
return addData(GapAdvertisingData::FLAGS, (uint8_t *)&flag, 1);
}
/**************************************************************************/
/*!
\brief Helper function to add TX_POWER_LEVEL data to the
advertising payload
\args[in] flag The TX_POWER_LEVEL value to add
\returns ble_error_t
\retval BLE_ERROR_NONE
Everything executed properly
\retval BLE_ERROR_BUFFER_OVERFLOW
The specified data would cause the advertising buffer
to overflow
\par EXAMPLE
\code
\endcode
*/
/**************************************************************************/
ble_error_t GapAdvertisingData::addTxPower(int8_t txPower)
{
/* ToDo: Basic error checking to make sure txPower is in range */
return addData(GapAdvertisingData::TX_POWER_LEVEL, (uint8_t *)&txPower, 1);
}
/**************************************************************************/
/*!
\brief Clears the payload and resets the payload length counter
*/
/**************************************************************************/
void GapAdvertisingData::clear(void)
{
memset(&_payload, 0, GAP_ADVERTISING_DATA_MAX_PAYLOAD);
_payloadLen = 0;
}
/**************************************************************************/
/*!
\brief Returns a pointer to the the current payload
\returns A pointer to the payload
*/
/**************************************************************************/
const uint8_t *GapAdvertisingData::getPayload(void) const
{
return (_payloadLen > 0) ? _payload : NULL;
}
/**************************************************************************/
/*!
\brief Returns the current payload length (0..31 bytes)
\returns The payload length in bytes
*/
/**************************************************************************/
uint8_t GapAdvertisingData::getPayloadLen(void) const
{
return _payloadLen;
}
/**************************************************************************/
/*!
\brief Returns the 16-bit appearance value for this device
\returns The 16-bit appearance value
*/
/**************************************************************************/
uint16_t GapAdvertisingData::getAppearance(void) const
{
return (uint16_t)_appearance;
}

368
GapAdvertisingData.h Normal file
View file

@ -0,0 +1,368 @@
/* 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 __GAP_ADVERTISING_DATA_H__
#define __GAP_ADVERTISING_DATA_H__
#include "blecommon.h"
#define GAP_ADVERTISING_DATA_MAX_PAYLOAD (31)
/**************************************************************************/
/*!
\brief
This class provides several helper functions to generate properly
formatted GAP Advertising and Scan Response data payloads
\note
See Bluetooth Specification 4.0 (Vol. 3), Part C, Section 11 and 18
for further information on Advertising and Scan Response data.
\par Advertising and Scan Response Payloads
Advertising data and Scan Response data are organized around a set of
data types called 'AD types' in Bluetooth 4.0 (see the Bluetooth Core
Specification v4.0, Vol. 3, Part C, Sections 11 and 18).
\par
Each AD type has it's own standardized 'assigned number', as defined
by the Bluetooth SIG:
https://www.bluetooth.org/en-us/specification/assigned-numbers/generic-access-profile
\par
For convenience sake, all appropriate AD types have been encapsulated
into GapAdvertisingData::DataType.
\par
Before the AD Types and their payload (if any) can be inserted into
the Advertising or Scan Response frames, they need to be formatted as
follows:
\li \c Record length (1 byte)
\li \c AD Type (1 byte)
\li \c AD payload (optional, only present if record length > 1)
\par
This class takes care of properly formatting the payload, performs
some basic checks on the payload length, and tries to avoid common
errors like adding an exclusive AD field twice in the Advertising
or Scan Response payload.
\par EXAMPLE
\code
// ToDo
\endcode
*/
/**************************************************************************/
class GapAdvertisingData
{
public:
/**********************************************************************/
/*!
\brief
A list of Advertising Data types commonly used by peripherals.
These AD types are used to describe the capabilities of the
peripheral, and get inserted inside the advertising or scan
response payloads.
\par Source
\li \c Bluetooth Core Specification 4.0 (Vol. 3), Part C, Section 11, 18
\li \c https://www.bluetooth.org/en-us/specification/assigned-numbers/generic-access-profile
*/
/**********************************************************************/
enum DataType
{
FLAGS = 0x01, /**< \ref
*Flags */
INCOMPLETE_LIST_16BIT_SERVICE_IDS = 0x02, /**<
*Incomplete
*list of
*16-bit
*Service IDs
**/
COMPLETE_LIST_16BIT_SERVICE_IDS = 0x03, /**< Complete
*list of
*16-bit
*Service IDs
**/
INCOMPLETE_LIST_32BIT_SERVICE_IDS = 0x04, /**<
*Incomplete
*list of
*32-bit
*Service IDs
*(not
*relevant for
*Bluetooth
*4.0) */
COMPLETE_LIST_32BIT_SERVICE_IDS = 0x05, /**< Complete
*list of
*32-bit
*Service IDs
*(not
*relevant for
*Bluetooth
*4.0) */
INCOMPLETE_LIST_128BIT_SERVICE_IDS = 0x06, /**<
*Incomplete
*list of
*128-bit
*Service IDs
**/
COMPLETE_LIST_128BIT_SERVICE_IDS = 0x07, /**< Complete
*list of
*128-bit
*Service IDs
**/
SHORTENED_LOCAL_NAME = 0x08, /**< Shortened
*Local Name
**/
COMPLETE_LOCAL_NAME = 0x09, /**< Complete
*Local Name
**/
TX_POWER_LEVEL = 0x0A, /**< TX Power
*Level (in
*dBm) */
DEVICE_ID = 0x10, /**< Device ID
**/
SLAVE_CONNECTION_INTERVAL_RANGE = 0x12, /**< Slave
*Connection
*Interval
*Range */
SERVICE_DATA = 0x16, /**< Service
*Data */
APPEARANCE = 0x19, /**< \ref
*Appearance
**/
ADVERTISING_INTERVAL = 0x1A, /**<
*Advertising
*Interval */
MANUFACTURER_SPECIFIC_DATA = 0xFF /**<
*Manufacturer
*Specific
*Data */
};
/**********************************************************************/
/*!
\brief
A list of values for the FLAGS AD Type
\note
You can use more than one value in the FLAGS AD Type (ex.
LE_GENERAL_DISCOVERABLE and BREDR_NOT_SUPPORTED).
\par Source
\li \c Bluetooth Core Specification 4.0 (Vol. 3), Part C, Section 18.1
*/
/**********************************************************************/
enum Flags
{
LE_LIMITED_DISCOVERABLE = 0x01, /**<
*Peripheral
*device is
*discoverable
*for a
*limited
*period of
*time */
LE_GENERAL_DISCOVERABLE = 0x02, /**<
*Peripheral
*device is
*discoverable
*at any
*moment */
BREDR_NOT_SUPPORTED = 0x04, /**<
*Peripheral
*device is LE
*only */
SIMULTANEOUS_LE_BREDR_C = 0x08, /**< Not
*relevant -
*central mode
*only */
SIMULTANEOUS_LE_BREDR_H = 0x10 /**< Not
*relevant -
*central mode
*only */
};
/**********************************************************************/
/*!
\brief
A list of values for the APPEARANCE AD Type, which describes the
physical shape or appearance of the device
\par Source
\li \c Bluetooth Core Specification Supplement, Part A, Section 1.12
\li \c Bluetooth Core Specification 4.0 (Vol. 3), Part C, Section 12.2
\li \c https://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.gap.appearance.xml
*/
/**********************************************************************/
enum Appearance
{
UNKNOWN = 0, /**< Unknown
*of
*unspecified
*appearance
*type */
GENERIC_PHONE = 64, /**< Generic
*Phone */
GENERIC_COMPUTER = 128, /**< Generic
*Computer */
GENERIC_WATCH = 192, /**< Generic
*Watch */
WATCH_SPORTS_WATCH = 193, /**< Sports
*Watch */
GENERIC_CLOCK = 256, /**< Generic
*Clock */
GENERIC_DISPLAY = 320, /**< Generic
*Display */
GENERIC_REMOTE_CONTROL = 384, /**< Generic
*Remote
*Control */
GENERIC_EYE_GLASSES = 448, /**< Generic
*Eye Glasses
**/
GENERIC_TAG = 512, /**< Generic
*Tag */
GENERIC_KEYRING = 576, /**< Generic
*Keyring */
GENERIC_MEDIA_PLAYER = 640, /**< Generic
*Media Player
**/
GENERIC_BARCODE_SCANNER = 704, /**< Generic
*Barcode
*Scanner */
GENERIC_THERMOMETER = 768, /**< Generic
*Thermometer
**/
THERMOMETER_EAR = 769, /**< Ear
*Thermometer
**/
GENERIC_HEART_RATE_SENSOR = 832, /**< Generic
*Heart Rate
*Sensor */
HEART_RATE_SENSOR_HEART_RATE_BELT = 833, /**< Belt
*Heart Rate
*Sensor */
GENERIC_BLOOD_PRESSURE = 896, /**< Generic
*Blood
*Pressure */
BLOOD_PRESSURE_ARM = 897, /**< Arm Blood
*Pressure */
BLOOD_PRESSURE_WRIST = 898, /**< Wrist
*Blood
*Pressure */
HUMAN_INTERFACE_DEVICE_HID = 960, /**< Human
*Interface
*Device (HID)
**/
KEYBOARD = 961, /**< Keyboard
**/
MOUSE = 962, /**< Mouse */
JOYSTICK = 963, /**< Joystick
**/
GAMEPAD = 964, /**< Gamepad
**/
DIGITIZER_TABLET = 965, /**< Digitizer
*Tablet */
CARD_READER = 966, /**< Card Read
**/
DIGITAL_PEN = 967, /**< Digital
*Pen */
BARCODE_SCANNER = 968, /**< Barcode
*Scanner */
GENERIC_GLUCOSE_METER = 1024, /**< Generic
*Glucose
*Meter */
GENERIC_RUNNING_WALKING_SENSOR = 1088, /**< Generic
*Running/Walking
*Sensor */
RUNNING_WALKING_SENSOR_IN_SHOE = 1089, /**< In Shoe
*Running/Walking
*Sensor */
RUNNING_WALKING_SENSOR_ON_SHOE = 1090, /**< On Shoe
*Running/Walking
*Sensor */
RUNNING_WALKING_SENSOR_ON_HIP = 1091, /**< On Hip
*Running/Walking
*Sensor */
GENERIC_CYCLING = 1152, /**< Generic
*Cycling */
CYCLING_CYCLING_COMPUTER = 1153, /**< Cycling
*Computer */
CYCLING_SPEED_SENSOR = 1154, /**< Cycling
*Speed Senspr
**/
CYCLING_CADENCE_SENSOR = 1155, /**< Cycling
*Cadence
*Sensor */
CYCLING_POWER_SENSOR = 1156, /**< Cycling
*Power Sensor
**/
CYCLING_SPEED_AND_CADENCE_SENSOR = 1157, /**< Cycling
*Speed and
*Cadence
*Sensor */
PULSE_OXIMETER_GENERIC = 3136, /**< Generic
*Pulse
*Oximeter */
PULSE_OXIMETER_FINGERTIP = 3137, /**< Fingertip
*Pulse
*Oximeter */
PULSE_OXIMETER_WRIST_WORN = 3138, /**< Wrist
*Worn Pulse
*Oximeter */
OUTDOOR_GENERIC = 5184, /**< Generic
*Outdoor */
OUTDOOR_LOCATION_DISPLAY_DEVICE = 5185, /**< Outdoor
*Location
*Display
*Device */
OUTDOOR_LOCATION_AND_NAVIGATION_DISPLAY_DEVICE = 5186, /**< Outdoor
*Location and
*Navigation
*Display
*Device */
OUTDOOR_LOCATION_POD = 5187, /**< Outdoor
*Location Pod
**/
OUTDOOR_LOCATION_AND_NAVIGATION_POD = 5188 /**< Outdoor
*Location and
*Navigation
*Pod */
};
GapAdvertisingData(void);
virtual ~GapAdvertisingData(void);
ble_error_t addData(DataType, const uint8_t *, uint8_t);
ble_error_t addAppearance(Appearance appearance = GENERIC_TAG);
ble_error_t addFlags(Flags flag = LE_GENERAL_DISCOVERABLE);
ble_error_t addTxPower(int8_t txPower);
void clear(void);
const uint8_t *getPayload(void) const;
uint8_t getPayloadLen(void) const;
uint16_t getAppearance(void) const;
private:
uint8_t _payload[GAP_ADVERTISING_DATA_MAX_PAYLOAD];
uint8_t _payloadLen;
uint16_t _appearance;
};
#endif // ifndef __GAP_ADVERTISING_DATA_H__

129
GapAdvertisingParams.cpp Normal file
View file

@ -0,0 +1,129 @@
/* 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 <stdio.h>
#include <string.h>
#include "blecommon.h"
#include "GapAdvertisingParams.h"
/**************************************************************************/
/*!
\brief
Instantiates a new GapAdvertisingParams instance
\param[in] advType
The GAP advertising mode to use for this device. Valid
values are defined in AdvertisingType:
\par ADV_NON_CONNECTABLE_UNDIRECTED
All connections to the peripheral device will be refused.
\par ADV_CONNECTABLE_DIRECTED
Only connections from a pre-defined central device will be
accepted.
\par ADV_CONNECTABLE_UNDIRECTED
Any central device can connect to this peripheral.
\par ADV_SCANNABLE_UNDIRECTED
Any central device can connect to this peripheral, and
the secondary Scan Response payload will be included or
available to central devices.
\par
See Bluetooth Core Specification 4.0 (Vol. 3), Part C,
Section 9.3 and Core Specification 4.0 (Vol. 6), Part B,
Section 2.3.1 for further information on GAP connection
modes
\param[in] interval
Advertising interval between 0x0020 and 0x4000 in 0.625ms units
(20ms to 10.24s). If using non-connectable mode
(ADV_NON_CONNECTABLE_UNDIRECTED) this min value is 0x00A0
(100ms). To reduce the likelihood of collisions, the link layer
perturbs this interval by a pseudo-random delay with a range of
0 ms to 10 ms for each advertising event.
\par
Decreasing this value will allow central devices to detect
your peripheral faster at the expense of more power being
used by the radio due to the higher data transmit rate.
\par
This field must be set to 0 if connectionMode is equal
to ADV_CONNECTABLE_DIRECTED
\par
See Bluetooth Core Specification, Vol 3., Part C,
Appendix A for suggested advertising intervals.
\param[in] timeout
Advertising timeout between 0x1 and 0x3FFF (1 and 16383)
in seconds. Enter 0 to disable the advertising timeout.
\par EXAMPLE
\code
\endcode
*/
/**************************************************************************/
GapAdvertisingParams::GapAdvertisingParams(AdvertisingType advType, uint16_t interval, uint16_t timeout)
{
_advType = advType;
_interval = interval;
_timeout = timeout;
/* Interval checks */
if (_advType == ADV_CONNECTABLE_DIRECTED) {
/* Interval must be 0 in directed connectable mode */
_interval = 0;
} else if (_advType == ADV_NON_CONNECTABLE_UNDIRECTED) {
/* Min interval is slightly larger than in other modes */
if (_interval < GAP_ADV_PARAMS_INTERVAL_MIN_NONCON) {
_interval = GAP_ADV_PARAMS_INTERVAL_MIN_NONCON;
}
if (_interval > GAP_ADV_PARAMS_INTERVAL_MAX) {
_interval = GAP_ADV_PARAMS_INTERVAL_MAX;
}
} else {
/* Stay within interval limits */
if (_interval < GAP_ADV_PARAMS_INTERVAL_MIN) {
_interval = GAP_ADV_PARAMS_INTERVAL_MIN;
}
if (_interval > GAP_ADV_PARAMS_INTERVAL_MAX) {
_interval = GAP_ADV_PARAMS_INTERVAL_MAX;
}
}
/* Timeout checks */
if (timeout) {
/* Stay within timeout limits */
if (_timeout > GAP_ADV_PARAMS_TIMEOUT_MAX) {
_timeout = GAP_ADV_PARAMS_TIMEOUT_MAX;
}
}
}
/**************************************************************************/
/*!
Destructor
*/
/**************************************************************************/
GapAdvertisingParams::~GapAdvertisingParams(void)
{
}

150
GapAdvertisingParams.h Normal file
View file

@ -0,0 +1,150 @@
/* 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 __GAP_ADVERTISING_PARAMS_H__
#define __GAP_ADVERTISING_PARAMS_H__
#include "blecommon.h"
#define GAP_ADV_PARAMS_INTERVAL_MIN (0x0020)
#define GAP_ADV_PARAMS_INTERVAL_MIN_NONCON (0x00A0)
#define GAP_ADV_PARAMS_INTERVAL_MAX (0x1000)
#define GAP_ADV_PARAMS_TIMEOUT_MAX (0x3FFF)
/**************************************************************************/
/*!
\brief
This class provides a wrapper for the core advertising parameters,
including the advertising type (Connectable Undirected,
Non Connectable Undirected, etc.), as well as the advertising and
timeout intervals.
\par
See the following for more information on advertising types:
\li \c Bluetooth Core Specification 4.0 (Vol. 6), Part B, Section 2.3.1
\li \c Bluetooth Core Specification 4.0 (Vol. 3), Part C, Section 9.3
\par EXAMPLE
\code
// ToDo
\endcode
*/
/**************************************************************************/
class GapAdvertisingParams
{
public:
/**************************************************************************/
/*!
\brief
Encapsulates the peripheral advertising modes, which determine how
the device appears to other central devices in hearing range
\par
See the following for more information on advertising types:
\li \c Bluetooth Core Specification 4.0 (Vol. 6), Part B, Section 2.3.1
\li \c Bluetooth Core Specification 4.0 (Vol. 3), Part C, Section 9.3
*/
/**************************************************************************/
enum AdvertisingType
{
ADV_CONNECTABLE_UNDIRECTED, /**< Vol 3, Part C, Section 9.3.4 and
*Vol 6, Part B, Section 2.3.1.1 */
ADV_CONNECTABLE_DIRECTED, /**< Vol 3, Part C, Section 9.3.3 and
*Vol 6, Part B, Section 2.3.1.2 */
ADV_SCANNABLE_UNDIRECTED, /**< Include support for Scan Response
*payloads, see Vol 6, Part B, Section
*2.3.1.4 */
ADV_NON_CONNECTABLE_UNDIRECTED /**< Vol 3, Part C, Section 9.3.2 and
*Vol 6, Part B, Section 2.3.1.3 */
};
GapAdvertisingParams(AdvertisingType advType =
GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED,
uint16_t interval =
GAP_ADV_PARAMS_INTERVAL_MIN_NONCON,
uint16_t timeout = 0);
virtual ~GapAdvertisingParams(void);
void setAdvertisingType(AdvertisingType newAdvType);
void setInterval(uint16_t newInterval);
void setTimeout(uint16_t newTimeout);
virtual AdvertisingType getAdvertisingType(void) const;
virtual uint16_t getInterval(void) const;
virtual uint16_t getTimeout(void) const;
private:
AdvertisingType _advType;
uint16_t _interval;
uint16_t _timeout;
};
inline void
GapAdvertisingParams::setAdvertisingType(AdvertisingType newAdvType) {
_advType = newAdvType;
}
inline void
GapAdvertisingParams::setInterval(uint16_t newInterval) {
_interval = newInterval;
}
inline void
GapAdvertisingParams::setTimeout(uint16_t newTimeout) {
_timeout = newTimeout;
}
/**************************************************************************/
/*!
\brief returns the current Advertising Type value
*/
/**************************************************************************/
inline GapAdvertisingParams::AdvertisingType
GapAdvertisingParams::getAdvertisingType(void) const
{
return _advType;
}
/**************************************************************************/
/*!
\brief returns the current Advertising Delay (in units of 0.625ms)
*/
/**************************************************************************/
inline uint16_t
GapAdvertisingParams::getInterval(void) const
{
return _interval;
}
/**************************************************************************/
/*!
\brief returns the current Advertising Timeout (in seconds)
*/
/**************************************************************************/
inline uint16_t
GapAdvertisingParams::getTimeout(void) const
{
return _timeout;
}
#endif // ifndef __GAP_ADVERTISING_PARAMS_H__

361
GattCharacteristic.h Normal file
View file

@ -0,0 +1,361 @@
/* 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_H__
#define __GATT_CHARACTERISTIC_H__
#include "blecommon.h"
#include "UUID.h"
#include "ble_gatts.h"
/**************************************************************************/
/*!
\brief GATT characteristic
*/
/**************************************************************************/
class GattCharacteristic
{
public:
enum {
UUID_BATTERY_LEVEL_STATE_CHAR = 0x2A1B,
UUID_BATTERY_POWER_STATE_CHAR = 0x2A1A,
UUID_REMOVABLE_CHAR = 0x2A3A,
UUID_SERVICE_REQUIRED_CHAR = 0x2A3B,
UUID_ALERT_CATEGORY_ID_CHAR = 0x2A43,
UUID_ALERT_CATEGORY_ID_BIT_MASK_CHAR = 0x2A42,
UUID_ALERT_LEVEL_CHAR = 0x2A06,
UUID_ALERT_NOTIFICATION_CONTROL_POINT_CHAR = 0x2A44,
UUID_ALERT_STATUS_CHAR = 0x2A3F,
UUID_BATTERY_LEVEL_CHAR = 0x2A19,
UUID_BLOOD_PRESSURE_FEATURE_CHAR = 0x2A49,
UUID_BLOOD_PRESSURE_MEASUREMENT_CHAR = 0x2A35,
UUID_BODY_SENSOR_LOCATION_CHAR = 0x2A38,
UUID_BOOT_KEYBOARD_INPUT_REPORT_CHAR = 0x2A22,
UUID_BOOT_KEYBOARD_OUTPUT_REPORT_CHAR = 0x2A32,
UUID_BOOT_MOUSE_INPUT_REPORT_CHAR = 0x2A33,
UUID_CURRENT_TIME_CHAR = 0x2A2B,
UUID_DATE_TIME_CHAR = 0x2A08,
UUID_DAY_DATE_TIME_CHAR = 0x2A0A,
UUID_DAY_OF_WEEK_CHAR = 0x2A09,
UUID_DST_OFFSET_CHAR = 0x2A0D,
UUID_EXACT_TIME_256_CHAR = 0x2A0C,
UUID_FIRMWARE_REVISION_STRING_CHAR = 0x2A26,
UUID_GLUCOSE_FEATURE_CHAR = 0x2A51,
UUID_GLUCOSE_MEASUREMENT_CHAR = 0x2A18,
UUID_GLUCOSE_MEASUREMENT_CONTEXT_CHAR = 0x2A34,
UUID_HARDWARE_REVISION_STRING_CHAR = 0x2A27,
UUID_HEART_RATE_CONTROL_POINT_CHAR = 0x2A39,
UUID_HEART_RATE_MEASUREMENT_CHAR = 0x2A37,
UUID_HID_CONTROL_POINT_CHAR = 0x2A4C,
UUID_HID_INFORMATION_CHAR = 0x2A4A,
UUID_IEEE_REGULATORY_CERTIFICATION_DATA_LIST_CHAR = 0x2A2A,
UUID_INTERMEDIATE_CUFF_PRESSURE_CHAR = 0x2A36,
UUID_INTERMEDIATE_TEMPERATURE_CHAR = 0x2A1E,
UUID_LOCAL_TIME_INFORMATION_CHAR = 0x2A0F,
UUID_MANUFACTURER_NAME_STRING_CHAR = 0x2A29,
UUID_MEASUREMENT_INTERVAL_CHAR = 0x2A21,
UUID_MODEL_NUMBER_STRING_CHAR = 0x2A24,
UUID_UNREAD_ALERT_CHAR = 0x2A45,
UUID_NEW_ALERT_CHAR = 0x2A46,
UUID_PNP_ID_CHAR = 0x2A50,
UUID_PROTOCOL_MODE_CHAR = 0x2A4E,
UUID_RECORD_ACCESS_CONTROL_POINT_CHAR = 0x2A52,
UUID_REFERENCE_TIME_INFORMATION_CHAR = 0x2A14,
UUID_REPORT_CHAR = 0x2A4D,
UUID_REPORT_MAP_CHAR = 0x2A4B,
UUID_RINGER_CONTROL_POINT_CHAR = 0x2A40,
UUID_RINGER_SETTING_CHAR = 0x2A41,
UUID_SCAN_INTERVAL_WINDOW_CHAR = 0x2A4F,
UUID_SCAN_REFRESH_CHAR = 0x2A31,
UUID_SERIAL_NUMBER_STRING_CHAR = 0x2A25,
UUID_SOFTWARE_REVISION_STRING_CHAR = 0x2A28,
UUID_SUPPORTED_NEW_ALERT_CATEGORY_CHAR = 0x2A47,
UUID_SUPPORTED_UNREAD_ALERT_CATEGORY_CHAR = 0x2A48,
UUID_SYSTEM_ID_CHAR = 0x2A23,
UUID_TEMPERATURE_MEASUREMENT_CHAR = 0x2A1C,
UUID_TEMPERATURE_TYPE_CHAR = 0x2A1D,
UUID_TIME_ACCURACY_CHAR = 0x2A12,
UUID_TIME_SOURCE_CHAR = 0x2A13,
UUID_TIME_UPDATE_CONTROL_POINT_CHAR = 0x2A16,
UUID_TIME_UPDATE_STATE_CHAR = 0x2A17,
UUID_TIME_WITH_DST_CHAR = 0x2A11,
UUID_TIME_ZONE_CHAR = 0x2A0E,
UUID_TX_POWER_LEVEL_CHAR = 0x2A07,
UUID_CSC_FEATURE_CHAR = 0x2A5C,
UUID_CSC_MEASUREMENT_CHAR = 0x2A5B,
UUID_RSC_FEATURE_CHAR = 0x2A54,
UUID_RSC_MEASUREMENT_CHAR = 0x2A53,
};
/**************************************************************************/
/*!
\brief Standard GATT characteristic presentation format unit types.
These unit types are used to decribe what the raw numeric
data in a characteristic actually represents.
\note See https://developer.bluetooth.org/gatt/units/Pages/default.aspx
*/
/**************************************************************************/
typedef enum ble_gatt_unit_e {
BLE_GATT_UNIT_NONE = 0x2700, /**< No specified unit type */
BLE_GATT_UNIT_LENGTH_METRE = 0x2701, /**< Length, Metre */
BLE_GATT_UNIT_MASS_KILOGRAM = 0x2702, /**< Mass, Kilogram */
BLE_GATT_UNIT_TIME_SECOND = 0x2703, /**< Time, Second */
BLE_GATT_UNIT_ELECTRIC_CURRENT_AMPERE = 0x2704, /**< Electric Current, Ampere */
BLE_GATT_UNIT_THERMODYNAMIC_TEMPERATURE_KELVIN = 0x2705, /**< Thermodynamic Temperature, Kelvin */
BLE_GATT_UNIT_AMOUNT_OF_SUBSTANCE_MOLE = 0x2706, /**< Amount of Substance, Mole */
BLE_GATT_UNIT_LUMINOUS_INTENSITY_CANDELA = 0x2707, /**< Luminous Intensity, Candela */
BLE_GATT_UNIT_AREA_SQUARE_METRES = 0x2710, /**< Area, Square Metres */
BLE_GATT_UNIT_VOLUME_CUBIC_METRES = 0x2711, /**< Volume, Cubic Metres*/
BLE_GATT_UNIT_VELOCITY_METRES_PER_SECOND = 0x2712, /**< Velocity, Metres per Second*/
BLE_GATT_UNIT_ACCELERATION_METRES_PER_SECOND_SQUARED = 0x2713, /**< Acceleration, Metres per Second Squared */
BLE_GATT_UNIT_WAVENUMBER_RECIPROCAL_METRE = 0x2714, /**< Wave Number Reciprocal, Metre */
BLE_GATT_UNIT_DENSITY_KILOGRAM_PER_CUBIC_METRE = 0x2715, /**< Density, Kilogram per Cubic Metre */
BLE_GATT_UNIT_SURFACE_DENSITY_KILOGRAM_PER_SQUARE_METRE = 0x2716, /**< */
BLE_GATT_UNIT_SPECIFIC_VOLUME_CUBIC_METRE_PER_KILOGRAM = 0x2717, /**< */
BLE_GATT_UNIT_CURRENT_DENSITY_AMPERE_PER_SQUARE_METRE = 0x2718, /**< */
BLE_GATT_UNIT_MAGNETIC_FIELD_STRENGTH_AMPERE_PER_METRE = 0x2719, /**< Magnetic Field Strength, Ampere per Metre */
BLE_GATT_UNIT_AMOUNT_CONCENTRATION_MOLE_PER_CUBIC_METRE = 0x271A, /**< */
BLE_GATT_UNIT_MASS_CONCENTRATION_KILOGRAM_PER_CUBIC_METRE = 0x271B, /**< */
BLE_GATT_UNIT_LUMINANCE_CANDELA_PER_SQUARE_METRE = 0x271C, /**< */
BLE_GATT_UNIT_REFRACTIVE_INDEX = 0x271D, /**< */
BLE_GATT_UNIT_RELATIVE_PERMEABILITY = 0x271E, /**< */
BLE_GATT_UNIT_PLANE_ANGLE_RADIAN = 0x2720, /**< */
BLE_GATT_UNIT_SOLID_ANGLE_STERADIAN = 0x2721, /**< */
BLE_GATT_UNIT_FREQUENCY_HERTZ = 0x2722, /**< Frequency, Hertz */
BLE_GATT_UNIT_FORCE_NEWTON = 0x2723, /**< Force, Newton */
BLE_GATT_UNIT_PRESSURE_PASCAL = 0x2724, /**< Pressure, Pascal */
BLE_GATT_UNIT_ENERGY_JOULE = 0x2725, /**< Energy, Joule */
BLE_GATT_UNIT_POWER_WATT = 0x2726, /**< Power, Watt */
BLE_GATT_UNIT_ELECTRIC_CHARGE_COULOMB = 0x2727, /**< Electrical Charge, Coulomb */
BLE_GATT_UNIT_ELECTRIC_POTENTIAL_DIFFERENCE_VOLT = 0x2728, /**< Electrical Potential Difference, Voltage */
BLE_GATT_UNIT_CAPACITANCE_FARAD = 0x2729, /**< */
BLE_GATT_UNIT_ELECTRIC_RESISTANCE_OHM = 0x272A, /**< */
BLE_GATT_UNIT_ELECTRIC_CONDUCTANCE_SIEMENS = 0x272B, /**< */
BLE_GATT_UNIT_MAGNETIC_FLEX_WEBER = 0x272C, /**< */
BLE_GATT_UNIT_MAGNETIC_FLEX_DENSITY_TESLA = 0x272D, /**< */
BLE_GATT_UNIT_INDUCTANCE_HENRY = 0x272E, /**< */
BLE_GATT_UNIT_THERMODYNAMIC_TEMPERATURE_DEGREE_CELSIUS = 0x272F, /**< */
BLE_GATT_UNIT_LUMINOUS_FLUX_LUMEN = 0x2730, /**< */
BLE_GATT_UNIT_ILLUMINANCE_LUX = 0x2731, /**< */
BLE_GATT_UNIT_ACTIVITY_REFERRED_TO_A_RADIONUCLIDE_BECQUEREL = 0x2732, /**< */
BLE_GATT_UNIT_ABSORBED_DOSE_GRAY = 0x2733, /**< */
BLE_GATT_UNIT_DOSE_EQUIVALENT_SIEVERT = 0x2734, /**< */
BLE_GATT_UNIT_CATALYTIC_ACTIVITY_KATAL = 0x2735, /**< */
BLE_GATT_UNIT_DYNAMIC_VISCOSITY_PASCAL_SECOND = 0x2740, /**< */
BLE_GATT_UNIT_MOMENT_OF_FORCE_NEWTON_METRE = 0x2741, /**< */
BLE_GATT_UNIT_SURFACE_TENSION_NEWTON_PER_METRE = 0x2742, /**< */
BLE_GATT_UNIT_ANGULAR_VELOCITY_RADIAN_PER_SECOND = 0x2743, /**< */
BLE_GATT_UNIT_ANGULAR_ACCELERATION_RADIAN_PER_SECOND_SQUARED = 0x2744, /**< */
BLE_GATT_UNIT_HEAT_FLUX_DENSITY_WATT_PER_SQUARE_METRE = 0x2745, /**< */
BLE_GATT_UNIT_HEAT_CAPACITY_JOULE_PER_KELVIN = 0x2746, /**< */
BLE_GATT_UNIT_SPECIFIC_HEAT_CAPACITY_JOULE_PER_KILOGRAM_KELVIN = 0x2747, /**< */
BLE_GATT_UNIT_SPECIFIC_ENERGY_JOULE_PER_KILOGRAM = 0x2748, /**< */
BLE_GATT_UNIT_THERMAL_CONDUCTIVITY_WATT_PER_METRE_KELVIN = 0x2749, /**< */
BLE_GATT_UNIT_ENERGY_DENSITY_JOULE_PER_CUBIC_METRE = 0x274A, /**< */
BLE_GATT_UNIT_ELECTRIC_FIELD_STRENGTH_VOLT_PER_METRE = 0x274B, /**< */
BLE_GATT_UNIT_ELECTRIC_CHARGE_DENSITY_COULOMB_PER_CUBIC_METRE = 0x274C, /**< */
BLE_GATT_UNIT_SURFACE_CHARGE_DENSITY_COULOMB_PER_SQUARE_METRE = 0x274D, /**< */
BLE_GATT_UNIT_ELECTRIC_FLUX_DENSITY_COULOMB_PER_SQUARE_METRE = 0x274E, /**< */
BLE_GATT_UNIT_PERMITTIVITY_FARAD_PER_METRE = 0x274F, /**< */
BLE_GATT_UNIT_PERMEABILITY_HENRY_PER_METRE = 0x2750, /**< */
BLE_GATT_UNIT_MOLAR_ENERGY_JOULE_PER_MOLE = 0x2751, /**< */
BLE_GATT_UNIT_MOLAR_ENTROPY_JOULE_PER_MOLE_KELVIN = 0x2752, /**< */
BLE_GATT_UNIT_EXPOSURE_COULOMB_PER_KILOGRAM = 0x2753, /**< */
BLE_GATT_UNIT_ABSORBED_DOSE_RATE_GRAY_PER_SECOND = 0x2754, /**< */
BLE_GATT_UNIT_RADIANT_INTENSITY_WATT_PER_STERADIAN = 0x2755, /**< */
BLE_GATT_UNIT_RADIANCE_WATT_PER_SQUARE_METRE_STERADIAN = 0x2756, /**< */
BLE_GATT_UNIT_CATALYTIC_ACTIVITY_CONCENTRATION_KATAL_PER_CUBIC_METRE = 0x2757, /**< */
BLE_GATT_UNIT_TIME_MINUTE = 0x2760, /**< Time, Minute */
BLE_GATT_UNIT_TIME_HOUR = 0x2761, /**< Time, Hour */
BLE_GATT_UNIT_TIME_DAY = 0x2762, /**< Time, Day */
BLE_GATT_UNIT_PLANE_ANGLE_DEGREE = 0x2763, /**< */
BLE_GATT_UNIT_PLANE_ANGLE_MINUTE = 0x2764, /**< */
BLE_GATT_UNIT_PLANE_ANGLE_SECOND = 0x2765, /**< */
BLE_GATT_UNIT_AREA_HECTARE = 0x2766, /**< */
BLE_GATT_UNIT_VOLUME_LITRE = 0x2767, /**< */
BLE_GATT_UNIT_MASS_TONNE = 0x2768, /**< */
BLE_GATT_UNIT_PRESSURE_BAR = 0x2780, /**< Pressure, Bar */
BLE_GATT_UNIT_PRESSURE_MILLIMETRE_OF_MERCURY = 0x2781, /**< Pressure, Millimetre of Mercury */
BLE_GATT_UNIT_LENGTH_ANGSTROM = 0x2782, /**< */
BLE_GATT_UNIT_LENGTH_NAUTICAL_MILE = 0x2783, /**< */
BLE_GATT_UNIT_AREA_BARN = 0x2784, /**< */
BLE_GATT_UNIT_VELOCITY_KNOT = 0x2785, /**< */
BLE_GATT_UNIT_LOGARITHMIC_RADIO_QUANTITY_NEPER = 0x2786, /**< */
BLE_GATT_UNIT_LOGARITHMIC_RADIO_QUANTITY_BEL = 0x2787, /**< */
BLE_GATT_UNIT_LENGTH_YARD = 0x27A0, /**< Length, Yard */
BLE_GATT_UNIT_LENGTH_PARSEC = 0x27A1, /**< Length, Parsec */
BLE_GATT_UNIT_LENGTH_INCH = 0x27A2, /**< Length, Inch */
BLE_GATT_UNIT_LENGTH_FOOT = 0x27A3, /**< Length, Foot */
BLE_GATT_UNIT_LENGTH_MILE = 0x27A4, /**< Length, Mile */
BLE_GATT_UNIT_PRESSURE_POUND_FORCE_PER_SQUARE_INCH = 0x27A5, /**< */
BLE_GATT_UNIT_VELOCITY_KILOMETRE_PER_HOUR = 0x27A6, /**< Velocity, Kilometre per Hour */
BLE_GATT_UNIT_VELOCITY_MILE_PER_HOUR = 0x27A7, /**< Velocity, Mile per Hour */
BLE_GATT_UNIT_ANGULAR_VELOCITY_REVOLUTION_PER_MINUTE = 0x27A8, /**< Angular Velocity, Revolution per Minute */
BLE_GATT_UNIT_ENERGY_GRAM_CALORIE = 0x27A9, /**< Energy, Gram Calorie */
BLE_GATT_UNIT_ENERGY_KILOGRAM_CALORIE = 0x27AA, /**< Energy, Kilogram Calorie */
BLE_GATT_UNIT_ENERGY_KILOWATT_HOUR = 0x27AB, /**< Energy, Killowatt Hour */
BLE_GATT_UNIT_THERMODYNAMIC_TEMPERATURE_DEGREE_FAHRENHEIT = 0x27AC, /**< */
BLE_GATT_UNIT_PERCENTAGE = 0x27AD, /**< Percentage */
BLE_GATT_UNIT_PER_MILLE = 0x27AE, /**< */
BLE_GATT_UNIT_PERIOD_BEATS_PER_MINUTE = 0x27AF, /**< */
BLE_GATT_UNIT_ELECTRIC_CHARGE_AMPERE_HOURS = 0x27B0, /**< */
BLE_GATT_UNIT_MASS_DENSITY_MILLIGRAM_PER_DECILITRE = 0x27B1, /**< */
BLE_GATT_UNIT_MASS_DENSITY_MILLIMOLE_PER_LITRE = 0x27B2, /**< */
BLE_GATT_UNIT_TIME_YEAR = 0x27B3, /**< Time, Year */
BLE_GATT_UNIT_TIME_MONTH = 0x27B4, /**< Time, Month */
BLE_GATT_UNIT_CONCENTRATION_COUNT_PER_CUBIC_METRE = 0x27B5, /**< */
BLE_GATT_UNIT_IRRADIANCE_WATT_PER_SQUARE_METRE = 0x27B6 /**< */
} ble_gatt_unit_t;
/**************************************************************************/
/*!
\brief Standard GATT number types
\note See Bluetooth Specification 4.0 (Vol. 3), Part G, Section 3.3.3.5.2
\note See http://developer.bluetooth.org/gatt/descriptors/Pages/DescriptorViewer.aspx?u=org.bluetooth.descriptor.gatt.characteristic_presentation_format.xml
*/
/**************************************************************************/
typedef enum ble_gatt_format_e {
BLE_GATT_FORMAT_RFU = 0x00, /**< Reserved For Future Use. */
BLE_GATT_FORMAT_BOOLEAN = 0x01, /**< Boolean. */
BLE_GATT_FORMAT_2BIT = 0x02, /**< Unsigned 2-bit integer. */
BLE_GATT_FORMAT_NIBBLE = 0x03, /**< Unsigned 4-bit integer. */
BLE_GATT_FORMAT_UINT8 = 0x04, /**< Unsigned 8-bit integer. */
BLE_GATT_FORMAT_UINT12 = 0x05, /**< Unsigned 12-bit integer. */
BLE_GATT_FORMAT_UINT16 = 0x06, /**< Unsigned 16-bit integer. */
BLE_GATT_FORMAT_UINT24 = 0x07, /**< Unsigned 24-bit integer. */
BLE_GATT_FORMAT_UINT32 = 0x08, /**< Unsigned 32-bit integer. */
BLE_GATT_FORMAT_UINT48 = 0x09, /**< Unsigned 48-bit integer. */
BLE_GATT_FORMAT_UINT64 = 0x0A, /**< Unsigned 64-bit integer. */
BLE_GATT_FORMAT_UINT128 = 0x0B, /**< Unsigned 128-bit integer. */
BLE_GATT_FORMAT_SINT8 = 0x0C, /**< Signed 2-bit integer. */
BLE_GATT_FORMAT_SINT12 = 0x0D, /**< Signed 12-bit integer. */
BLE_GATT_FORMAT_SINT16 = 0x0E, /**< Signed 16-bit integer. */
BLE_GATT_FORMAT_SINT24 = 0x0F, /**< Signed 24-bit integer. */
BLE_GATT_FORMAT_SINT32 = 0x10, /**< Signed 32-bit integer. */
BLE_GATT_FORMAT_SINT48 = 0x11, /**< Signed 48-bit integer. */
BLE_GATT_FORMAT_SINT64 = 0x12, /**< Signed 64-bit integer. */
BLE_GATT_FORMAT_SINT128 = 0x13, /**< Signed 128-bit integer. */
BLE_GATT_FORMAT_FLOAT32 = 0x14, /**< IEEE-754 32-bit floating point. */
BLE_GATT_FORMAT_FLOAT64 = 0x15, /**< IEEE-754 64-bit floating point. */
BLE_GATT_FORMAT_SFLOAT = 0x16, /**< IEEE-11073 16-bit SFLOAT. */
BLE_GATT_FORMAT_FLOAT = 0x17, /**< IEEE-11073 32-bit FLOAT. */
BLE_GATT_FORMAT_DUINT16 = 0x18, /**< IEEE-20601 format. */
BLE_GATT_FORMAT_UTF8S = 0x19, /**< UTF-8 string. */
BLE_GATT_FORMAT_UTF16S = 0x1A, /**< UTF-16 string. */
BLE_GATT_FORMAT_STRUCT = 0x1B /**< Opaque Structure. */
} ble_gatt_format_t;
/**************************************************************************/
/*!
\brief Standard GATT characteritic properties
\note See Bluetooth Specification 4.0 (Vol. 3), Part G, Section 3.3.1.1
and Section 3.3.3.1 for Extended Properties
*/
/**************************************************************************/
typedef enum ble_gatt_char_properties_e {
BLE_GATT_CHAR_PROPERTIES_NONE = 0x00,
BLE_GATT_CHAR_PROPERTIES_BROADCAST = 0x01, /**< Permits broadcasts of the Characteristic Value using Server Characteristic Configuration Descriptor. */
BLE_GATT_CHAR_PROPERTIES_READ = 0x02, /**< Permits reads of the Characteristic Value. */
BLE_GATT_CHAR_PROPERTIES_WRITE_WITHOUT_RESPONSE = 0x04, /**< Permits writes of the Characteristic Value without response. */
BLE_GATT_CHAR_PROPERTIES_WRITE = 0x08, /**< Permits writes of the Characteristic Value with response. */
BLE_GATT_CHAR_PROPERTIES_NOTIFY = 0x10, /**< Permits notifications of a Characteristic Value without acknowledgement. */
BLE_GATT_CHAR_PROPERTIES_INDICATE = 0x20, /**< Permits indications of a Characteristic Value with acknowledgement. */
BLE_GATT_CHAR_PROPERTIES_AUTHENTICATED_SIGNED_WRITES = 0x40, /**< Permits signed writes to the Characteristic Value. */
BLE_GATT_CHAR_PROPERTIES_EXTENDED_PROPERTIES = 0x80 /**< Additional characteristic properties are defined in the Characteristic Extended Properties Descriptor */
} ble_gatt_char_properties_t;
/**************************************************************************/
/*!
\brief GATT presentation format wrapper
\note See Bluetooth Specification 4.0 (Vol. 3), Part G, Section 3.3.3.5
\note See https://developer.bluetooth.org/gatt/descriptors/Pages/DescriptorViewer.aspx?u=org.bluetooth.descriptor.gatt.characteristic_presentation_format.xml
*/
/**************************************************************************/
typedef struct PresentationFormat {
uint8_t gatt_format; /**< Format of the value, see @ref ble_gatt_format_t. */
int8_t exponent; /**< Exponent for integer data types. Ex. if Exponent = -3 and the char value is 3892, the actual value is 3.892 */
uint16_t gatt_unit; /**< UUID from Bluetooth Assigned Numbers, see @ref ble_gatt_unit_t. */
uint8_t gatt_namespace; /**< Namespace from Bluetooth Assigned Numbers, normally '1', see @ref BLE_GATT_CPF_NAMESPACES. */
uint16_t gatt_nsdesc; /**< Namespace description from Bluetooth Assigned Numbers, normally '0', see @ref BLE_GATT_CPF_NAMESPACES. */
} presentation_format_t;
/**
* @brief Creates a new GattCharacteristic using the specified 16-bit
* UUID, value length, and properties
*
* @note The UUID value must be unique in the service and is normally >1
*
* @param[in] uuid
* The UUID to use for this characteristic
* @param[in] props
* The 8-bit bit field containing the characteristic's properties
* @param[in] initialLen
* The min length in bytes of this characteristic's value
* @param[in] maxLen
* The max length in bytes of this characteristic's value
*
* @section EXAMPLE
*
* @code
*
* // UUID = 0x2A19, Min length 2, Max len = 2, Properties = write
* GattCharacteristic c = GattCharacteristic( 0x2A19, 2, 2, BLE_GATT_CHAR_PROPERTIES_WRITE );
*
* @endcode
*/
/**************************************************************************/
GattCharacteristic(const UUID &uuid, uint8_t *value = NULL, uint16_t initialLen = 0, uint16_t maxLen = 0,
uint8_t props = BLE_GATT_CHAR_PROPERTIES_NONE) :
_uuid(uuid), _value(value), _initialLen(initialLen), _lenMax(maxLen), _handle(), _properties(props) {
/* empty */
}
public:
uint16_t getHandle(void) const {
return _handle;
}
void setHandle(uint16_t id) {
_handle = id;
}
const UUID &getUUID(void) const {
return _uuid;
}
uint8_t getProperties(void) const {
return _properties;
}
uint16_t getInitialLength(void) const {
return _initialLen;
}
uint16_t getMaxLength(void) const {
return _lenMax;
}
private:
UUID _uuid; /* Characteristic UUID */
uint8_t *_value;
uint16_t _initialLen; /* Initial length of the value */
uint16_t _lenMax; /* Maximum length of the value */
uint16_t _handle;
uint8_t _properties;
};
#endif // ifndef __GATT_CHARACTERISTIC_H__

91
GattService.cpp Normal file
View file

@ -0,0 +1,91 @@
/* 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 <stdio.h>
#include <string.h>
#include "GattService.h"
/**************************************************************************/
/*!
@brief Creates a new GattService using the specified 128-bit UUID
@note The UUID value must be unique on the device
@param[in] uuid
The 16 byte (128-bit) UUID to use for this characteristic
@section EXAMPLE
@code
@endcode
*/
/**************************************************************************/
GattService::GattService(UUID uuid) :
primaryServiceID(uuid),
characteristicCount(0),
characteristics(),
handle(0)
{
/* empty */
}
/**************************************************************************/
/*!
@brief Destructor
*/
/**************************************************************************/
GattService::~GattService(void)
{
}
/**************************************************************************/
/*!
@brief Adds a GattCharacterisic to the service.
@note This function will not update the .handle field in the
GattCharacteristic. This value is updated when the parent
service is added via the radio driver.
@param[in] characteristic
The GattCharacteristic object describing the characteristic
to add to this service
@returns BLE_ERROR_NONE (0) if everything executed correctly, or an
error code if there was a problem
@retval BLE_ERROR_NONE
Everything executed correctly
@section EXAMPLE
@code
@endcode
*/
/**************************************************************************/
ble_error_t GattService::addCharacteristic(GattCharacteristic & characteristic)
{
/* ToDo: Make sure we don't overflow the array, etc. */
/* ToDo: Make sure this characteristic UUID doesn't already exist */
/* ToDo: Basic validation */
characteristics[characteristicCount] = &characteristic;
characteristicCount++;
return BLE_ERROR_NONE;
}

90
GattService.h Normal file
View file

@ -0,0 +1,90 @@
/* 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_SERVICE_H__
#define __GATT_SERVICE_H__
#include "blecommon.h"
#include "UUID.h"
#include "GattCharacteristic.h"
#define BLE_SERVICE_MAX_CHARACTERISTICS (5)
/**************************************************************************/
/*!
\brief GATT service
*/
/**************************************************************************/
class GattService
{
private:
public:
GattService(UUID uuid);
virtual ~GattService(void);
ble_error_t addCharacteristic(GattCharacteristic &);
enum {
UUID_ALERT_NOTIFICATION_SERVICE = 0x1811,
UUID_BATTERY_SERVICE = 0x180F,
UUID_BLOOD_PRESSURE_SERVICE = 0x1810,
UUID_CURRENT_TIME_SERVICE = 0x1805,
UUID_CYCLING_SPEED_AND_CADENCE = 0x1816,
UUID_DEVICE_INFORMATION_SERVICE = 0x180A,
UUID_GLUCOSE_SERVICE = 0x1808,
UUID_HEALTH_THERMOMETER_SERVICE = 0x1809,
UUID_HEART_RATE_SERVICE = 0x180D,
UUID_HUMAN_INTERFACE_DEVICE_SERVICE = 0x1812,
UUID_IMMEDIATE_ALERT_SERVICE = 0x1802,
UUID_LINK_LOSS_SERVICE = 0x1803,
UUID_NEXT_DST_CHANGE_SERVICE = 0x1807,
UUID_PHONE_ALERT_STATUS_SERVICE = 0x180E,
UUID_REFERENCE_TIME_UPDATE_SERVICE = 0x1806,
UUID_RUNNING_SPEED_AND_CADENCE = 0x1814,
UUID_SCAN_PARAMETERS_SERVICE = 0x1813,
UUID_TX_POWER_SERVICE = 0x1804
};
const UUID &getUUID(void) const {
return primaryServiceID;
}
uint16_t *getHandlePtr(void) {
return &handle;
}
uint16_t getHandle(void) const {
return handle;
}
uint8_t getCharacteristicCount(void) const {
return characteristicCount;
}
GattCharacteristic *getCharacteristic(uint8_t index) {
if (index >= characteristicCount) {
return NULL;
}
return characteristics[index];
}
private:
UUID primaryServiceID;
uint8_t characteristicCount;
GattCharacteristic *characteristics[BLE_SERVICE_MAX_CHARACTERISTICS];
uint16_t handle;
};
#endif // ifndef __GATT_SERVICE_H__

113
UUID.cpp Normal file
View file

@ -0,0 +1,113 @@
/* 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 <stdio.h>
#include <string.h>
#include "UUID.h"
/**************************************************************************/
/*!
@brief 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.
@note When creating a UUID, the constructor will check if all bytes
except bytes 2/3 are equal to 0. If only bytes 2/3 have a
value, the UUID will be treated as a short/BLE UUID, and the
.type field will be set to UUID::UUID_TYPE_SHORT. If any
of the bytes outside byte 2/3 have a non-zero value, the UUID
will be considered a 128-bit ID, and .type will be assigned
as UUID::UUID_TYPE_LONG.
@param[in] uuid_base
The 128-bit (16-byte) UUID value. For 128-bit values,
assign all 16 bytes. For 16-bit values, assign the
16-bits to byte 2 and 3, and leave the rest of the bytes
as 0.
@section EXAMPLE
@code
// Create a short UUID (0x180F)
uint8_t shortID[16] = { 0, 0, 0x0F, 0x18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
UUID ble_uuid = UUID(shortID);
// ble_uuid.type = UUID_TYPE_SHORT
// ble_uuid.value = 0x180F
// Creeate a long UUID
uint8_t longID[16] = { 0x00, 0x11, 0x22, 0x33,
0x44, 0x55, 0x66, 0x77,
0x88, 0x99, 0xAA, 0xBB,
0xCC, 0xDD, 0xEE, 0xFF };
UUID custom_uuid = UUID(longID);
// custom_uuid.type = UUID_TYPE_LONG
// custom_uuid.value = 0x3322
// custom_uuid.base = 00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF
@endcode
*/
/**************************************************************************/
UUID::UUID(const LongUUID_t longUUID) : type(UUID_TYPE_SHORT), baseUUID(), shortUUID(0)
{
memcpy(baseUUID, longUUID, LENGTH_OF_LONG_UUID);
shortUUID = (uint16_t)((longUUID[2] << 8) | (longUUID[3]));
/* Check if this is a short of a long UUID */
unsigned index;
for (index = 0; index < LENGTH_OF_LONG_UUID; index++) {
if ((index == 2) || (index == 3)) {
continue; /* we should not consider bytes 2 and 3 because that's
* where the 16-bit relative UUID is placed. */
}
if (baseUUID[index] != 0) {
type = UUID_TYPE_LONG;
/* zero out the 16-bit part in the base; this will help equate long
* UUIDs when they differ only in this 16-bit relative part.*/