Denislam Valeev / Mbed OS Nucleo_rtos_basic

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.

mbed-os/features/FEATURE_BLE/ble/Gap.h@0:e056ac8fecf8, 2018-03-13 (annotated)

Committer:
valeyev
Date:
Tue Mar 13 07:17:50 2018 +0000
Revision:
0:e056ac8fecf8
looking for...

Who changed what in which revision?

UserRevisionLine numberNew contents of line
valeyev 0:e056ac8fecf8 1 /* mbed Microcontroller Library
valeyev 0:e056ac8fecf8 2 * Copyright (c) 2006-2013 ARM Limited
valeyev 0:e056ac8fecf8 3 *
valeyev 0:e056ac8fecf8 4 * Licensed under the Apache License, Version 2.0 (the "License");
valeyev 0:e056ac8fecf8 5 * you may not use this file except in compliance with the License.
valeyev 0:e056ac8fecf8 6 * You may obtain a copy of the License at
valeyev 0:e056ac8fecf8 7 *
valeyev 0:e056ac8fecf8 8 * http://www.apache.org/licenses/LICENSE-2.0
valeyev 0:e056ac8fecf8 9 *
valeyev 0:e056ac8fecf8 10 * Unless required by applicable law or agreed to in writing, software
valeyev 0:e056ac8fecf8 11 * distributed under the License is distributed on an "AS IS" BASIS,
valeyev 0:e056ac8fecf8 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
valeyev 0:e056ac8fecf8 13 * See the License for the specific language governing permissions and
valeyev 0:e056ac8fecf8 14 * limitations under the License.
valeyev 0:e056ac8fecf8 15 */
valeyev 0:e056ac8fecf8 16
valeyev 0:e056ac8fecf8 17 #ifndef MBED_BLE_GAP_H__
valeyev 0:e056ac8fecf8 18 #define MBED_BLE_GAP_H__
valeyev 0:e056ac8fecf8 19
valeyev 0:e056ac8fecf8 20 #include "BLETypes.h"
valeyev 0:e056ac8fecf8 21 #include "BLEProtocol.h"
valeyev 0:e056ac8fecf8 22 #include "GapAdvertisingData.h"
valeyev 0:e056ac8fecf8 23 #include "GapAdvertisingParams.h"
valeyev 0:e056ac8fecf8 24 #include "GapScanningParams.h"
valeyev 0:e056ac8fecf8 25 #include "GapEvents.h"
valeyev 0:e056ac8fecf8 26 #include "CallChainOfFunctionPointersWithContext.h"
valeyev 0:e056ac8fecf8 27 #include "FunctionPointerWithContext.h"
valeyev 0:e056ac8fecf8 28 #include "platform/mbed_toolchain.h"
valeyev 0:e056ac8fecf8 29
valeyev 0:e056ac8fecf8 30 /* Forward declarations for classes that are only used for pointers or
valeyev 0:e056ac8fecf8 31 references. */
valeyev 0:e056ac8fecf8 32 class GapAdvertisingParams;
valeyev 0:e056ac8fecf8 33 class GapScanningParams;
valeyev 0:e056ac8fecf8 34 class GapAdvertisingData;
valeyev 0:e056ac8fecf8 35
valeyev 0:e056ac8fecf8 36 /**
valeyev 0:e056ac8fecf8 37 * @addtogroup ble
valeyev 0:e056ac8fecf8 38 * @{
valeyev 0:e056ac8fecf8 39 * @addtogroup gap
valeyev 0:e056ac8fecf8 40 * @{
valeyev 0:e056ac8fecf8 41 */
valeyev 0:e056ac8fecf8 42
valeyev 0:e056ac8fecf8 43 /**
valeyev 0:e056ac8fecf8 44 * Define device discovery, connection and link management procedures.
valeyev 0:e056ac8fecf8 45 *
valeyev 0:e056ac8fecf8 46 * - Device discovery: A device can advertise nearby peers of its existence,
valeyev 0:e056ac8fecf8 47 * identity and capabilities. Similarly, a device can scan its environment to
valeyev 0:e056ac8fecf8 48 * find advertising peers. The information acquired during the scan helps to
valeyev 0:e056ac8fecf8 49 * identify peers and understand their use. A scanner may acquire more information
valeyev 0:e056ac8fecf8 50 * about an advertising peer by sending a scan request. If the peer accepts scan
valeyev 0:e056ac8fecf8 51 * requests, it may reply with additional information about its state.
valeyev 0:e056ac8fecf8 52 *
valeyev 0:e056ac8fecf8 53 * - Connection: A bluetooth device can establish a connection to a connectable
valeyev 0:e056ac8fecf8 54 * advertising peer. Once the connection is established, both devices can
valeyev 0:e056ac8fecf8 55 * communicate using the GATT protocol. The GATT protocol allows connected
valeyev 0:e056ac8fecf8 56 * devices to expose a set of states that the other peer can discover, read and write.
valeyev 0:e056ac8fecf8 57 *
valeyev 0:e056ac8fecf8 58 * - Link Management: Connected devices may drop the connection and may adjust
valeyev 0:e056ac8fecf8 59 * connection parameters according to the power envelop needed for their
valeyev 0:e056ac8fecf8 60 * application.
valeyev 0:e056ac8fecf8 61 *
valeyev 0:e056ac8fecf8 62 * @par Accessing gap
valeyev 0:e056ac8fecf8 63 *
valeyev 0:e056ac8fecf8 64 * Instance of a Gap class for a given BLE device should be accessed using
valeyev 0:e056ac8fecf8 65 * BLE::gap(). The reference returned remains valid until the BLE instance
valeyev 0:e056ac8fecf8 66 * shut down (see BLE::shutdown()).
valeyev 0:e056ac8fecf8 67 *
valeyev 0:e056ac8fecf8 68 * @code
valeyev 0:e056ac8fecf8 69 * // assuming ble_device has been initialized
valeyev 0:e056ac8fecf8 70 * BLE& ble_device;
valeyev 0:e056ac8fecf8 71 *
valeyev 0:e056ac8fecf8 72 * Gap& gap = ble_device.gap();
valeyev 0:e056ac8fecf8 73 * @endcode
valeyev 0:e056ac8fecf8 74 *
valeyev 0:e056ac8fecf8 75 * @par Advertising
valeyev 0:e056ac8fecf8 76 *
valeyev 0:e056ac8fecf8 77 * Advertising consists of broadcasting at a regular interval a small amount of
valeyev 0:e056ac8fecf8 78 * data containing valuable informations about the device. These packets may be
valeyev 0:e056ac8fecf8 79 * scanned by peer devices listening on BLE advertising channels.
valeyev 0:e056ac8fecf8 80 *
valeyev 0:e056ac8fecf8 81 * Scanners may also request additional information from a device advertising by
valeyev 0:e056ac8fecf8 82 * sending a scan request. If the broadcaster accepts scan requests, it can reply
valeyev 0:e056ac8fecf8 83 * with a scan response packet containing additional information.
valeyev 0:e056ac8fecf8 84 *
valeyev 0:e056ac8fecf8 85 * @code
valeyev 0:e056ac8fecf8 86 * // assuming gap has been initialized
valeyev 0:e056ac8fecf8 87 * Gap& gap;
valeyev 0:e056ac8fecf8 88 *
valeyev 0:e056ac8fecf8 89 * // construct the packet to advertise
valeyev 0:e056ac8fecf8 90 * GapAdvertisingData advertising_data;
valeyev 0:e056ac8fecf8 91 *
valeyev 0:e056ac8fecf8 92 * // Add advertiser flags
valeyev 0:e056ac8fecf8 93 * advertising_data.addFlags(
valeyev 0:e056ac8fecf8 94 * GapAdvertisingData::LE_GENERAL_DISCOVERABLE |
valeyev 0:e056ac8fecf8 95 * GapAdvertisingData::BREDR_NOT_SUPPORTED
valeyev 0:e056ac8fecf8 96 * );
valeyev 0:e056ac8fecf8 97 *
valeyev 0:e056ac8fecf8 98 * // Add the name of the device to the advertising data
valeyev 0:e056ac8fecf8 99 * static const uint8_t device_name[] = "HRM";
valeyev 0:e056ac8fecf8 100 * advertising_data.addData(
valeyev 0:e056ac8fecf8 101 * GapAdvertisingData::COMPLETE_LOCAL_NAME,
valeyev 0:e056ac8fecf8 102 * device_name,
valeyev 0:e056ac8fecf8 103 * sizeof(device_name)
valeyev 0:e056ac8fecf8 104 * );
valeyev 0:e056ac8fecf8 105 *
valeyev 0:e056ac8fecf8 106 * // set the advertising data in the gap instance, they will be used when
valeyev 0:e056ac8fecf8 107 * // advertising starts.
valeyev 0:e056ac8fecf8 108 * gap.setAdvertisingPayload(advertising_data);
valeyev 0:e056ac8fecf8 109 *
valeyev 0:e056ac8fecf8 110 * // Configure the advertising procedure
valeyev 0:e056ac8fecf8 111 * GapAdvertisingParams advertising_params(
valeyev 0:e056ac8fecf8 112 * GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED, // type of advertising
valeyev 0:e056ac8fecf8 113 * GapAdvertisingParams::MSEC_TO_ADVERTISEMENT_DURATION_UNITS(1000), // interval
valeyev 0:e056ac8fecf8 114 * 0 // The advertising procedure will not timeout
valeyev 0:e056ac8fecf8 115 * );
valeyev 0:e056ac8fecf8 116 *
valeyev 0:e056ac8fecf8 117 * gap.setAdvertisingParams(advertising_params);
valeyev 0:e056ac8fecf8 118 *
valeyev 0:e056ac8fecf8 119 * // start the advertising procedure, the device will advertise its flag and the
valeyev 0:e056ac8fecf8 120 * // name "HRM". Other peers will also be allowed to connect to it.
valeyev 0:e056ac8fecf8 121 * gap.startAdvertising();
valeyev 0:e056ac8fecf8 122 * @endcode
valeyev 0:e056ac8fecf8 123 *
valeyev 0:e056ac8fecf8 124 * @par Scanning
valeyev 0:e056ac8fecf8 125 *
valeyev 0:e056ac8fecf8 126 * Scanning consist of listening for peer advertising packets. From a scan, a
valeyev 0:e056ac8fecf8 127 * device can identify devices available in its environment.
valeyev 0:e056ac8fecf8 128 *
valeyev 0:e056ac8fecf8 129 * If the device scans actively, then it will send scan request to scannable
valeyev 0:e056ac8fecf8 130 * advertisers and collect their scan response.
valeyev 0:e056ac8fecf8 131 *
valeyev 0:e056ac8fecf8 132 * @code
valeyev 0:e056ac8fecf8 133 * // assuming gap has been initialized
valeyev 0:e056ac8fecf8 134 * Gap& gap;
valeyev 0:e056ac8fecf8 135 *
valeyev 0:e056ac8fecf8 136 * // Handle advertising packet by dumping their content
valeyev 0:e056ac8fecf8 137 * void handle_advertising_packet(const AdvertisementCallbackParams_t* packet)
valeyev 0:e056ac8fecf8 138 * {
valeyev 0:e056ac8fecf8 139 * printf("Packet received: \r\n");
valeyev 0:e056ac8fecf8 140 * printf(" - peer address: %02X:%02X:%02X:%02X:%02X:%02X\r\n",
valeyev 0:e056ac8fecf8 141 * packet->peerAddr[5], packet->peerAddr[4], packet->peerAddr[3],
valeyev 0:e056ac8fecf8 142 * packet->peerAddr[2], packet->peerAddr[1], packet->peerAddr[0]);
valeyev 0:e056ac8fecf8 143 * printf(" - rssi: %d", packet->rssi);
valeyev 0:e056ac8fecf8 144 * printf(" - scan response: %s\r\n", packet->isScanresponse ? "true" : "false");
valeyev 0:e056ac8fecf8 145 * printf(" - advertising type: %d\r\n", packet->type);
valeyev 0:e056ac8fecf8 146 * printf(" - advertising type: %d\r\n", packet->type);
valeyev 0:e056ac8fecf8 147 * printf(" - Advertising data: \r\n");
valeyev 0:e056ac8fecf8 148 *
valeyev 0:e056ac8fecf8 149 * // parse advertising data, it is a succession of AD structures where
valeyev 0:e056ac8fecf8 150 * // the first byte is the size of the AD structure, the second byte the
valeyev 0:e056ac8fecf8 151 * // type of the data and remaining bytes are the value.
valeyev 0:e056ac8fecf8 152 *
valeyev 0:e056ac8fecf8 153 * for (size_t i = 0; i < packet->advertisingDataLen; i += packet->advertisingData[i]) {
valeyev 0:e056ac8fecf8 154 * printf(" - type: 0X%02X, data: ", packet->advertisingData[i + 1]);
valeyev 0:e056ac8fecf8 155 * for (size_t j = 0; j < packet->advertisingData[i] - 2; ++j) {
valeyev 0:e056ac8fecf8 156 * printf("0X%02X ", packet->advertisingData[i + 2 + j]);
valeyev 0:e056ac8fecf8 157 * }
valeyev 0:e056ac8fecf8 158 * printf("\r\n");
valeyev 0:e056ac8fecf8 159 * }
valeyev 0:e056ac8fecf8 160 * }
valeyev 0:e056ac8fecf8 161 *
valeyev 0:e056ac8fecf8 162 * // set the scan parameters
valeyev 0:e056ac8fecf8 163 * gap.setScanParams(
valeyev 0:e056ac8fecf8 164 * 100, // interval between two scan window in ms
valeyev 0:e056ac8fecf8 165 * 50, // scan window: period during which the device listen for advertising packets.
valeyev 0:e056ac8fecf8 166 * 0, // the scan process never ends
valeyev 0:e056ac8fecf8 167 * true // the device sends scan request to scannable peers.
valeyev 0:e056ac8fecf8 168 * );
valeyev 0:e056ac8fecf8 169 *
valeyev 0:e056ac8fecf8 170 * // start the scan procedure
valeyev 0:e056ac8fecf8 171 * gap.startScan(handle_advertising_packet);
valeyev 0:e056ac8fecf8 172 * @endcode
valeyev 0:e056ac8fecf8 173 *
valeyev 0:e056ac8fecf8 174 * @par Connection event handling
valeyev 0:e056ac8fecf8 175 *
valeyev 0:e056ac8fecf8 176 * A peer may connect device advertising connectable packets. The
valeyev 0:e056ac8fecf8 177 * advertising procedure ends as soon as the device is connected.
valeyev 0:e056ac8fecf8 178 *
valeyev 0:e056ac8fecf8 179 * A device accepting a connection request from a peer is named a peripheral,
valeyev 0:e056ac8fecf8 180 * and the device initiating the connection is named a central.
valeyev 0:e056ac8fecf8 181 *
valeyev 0:e056ac8fecf8 182 * Peripheral and central receive a connection event when the connection is
valeyev 0:e056ac8fecf8 183 * effective.
valeyev 0:e056ac8fecf8 184 *
valeyev 0:e056ac8fecf8 185 * @code
valeyev 0:e056ac8fecf8 186 * Gap& gap;
valeyev 0:e056ac8fecf8 187 *
valeyev 0:e056ac8fecf8 188 * // handle connection event
valeyev 0:e056ac8fecf8 189 * void when_connected(const ConnectionCallbackParams_t *connection_event) {
valeyev 0:e056ac8fecf8 190 * // If this callback is entered, then the connection to a peer is effective.
valeyev 0:e056ac8fecf8 191 * }
valeyev 0:e056ac8fecf8 192 *
valeyev 0:e056ac8fecf8 193 * // register connection event handler, which will be invoked whether the device
valeyev 0:e056ac8fecf8 194 * // acts as a central or a peripheral
valeyev 0:e056ac8fecf8 195 * gap.onConnection(when_connected);
valeyev 0:e056ac8fecf8 196 * @endcode
valeyev 0:e056ac8fecf8 197 *
valeyev 0:e056ac8fecf8 198 * @par Connection initiation
valeyev 0:e056ac8fecf8 199 *
valeyev 0:e056ac8fecf8 200 * Connection is initiated central devices.
valeyev 0:e056ac8fecf8 201 *
valeyev 0:e056ac8fecf8 202 * @code
valeyev 0:e056ac8fecf8 203 * // assuming gap has been initialized
valeyev 0:e056ac8fecf8 204 * Gap& gap;
valeyev 0:e056ac8fecf8 205 *
valeyev 0:e056ac8fecf8 206 * // Handle the connection event
valeyev 0:e056ac8fecf8 207 * void handle_connection(const ConnectionCallbackParams_t* connection_event)
valeyev 0:e056ac8fecf8 208 * {
valeyev 0:e056ac8fecf8 209 * // event handling
valeyev 0:e056ac8fecf8 210 * }
valeyev 0:e056ac8fecf8 211 *
valeyev 0:e056ac8fecf8 212 * // Handle advertising packet: connect to the first connectable device
valeyev 0:e056ac8fecf8 213 * void handle_advertising_packet(const AdvertisementCallbackParams_t* packet)
valeyev 0:e056ac8fecf8 214 * {
valeyev 0:e056ac8fecf8 215 * if (packet->type != GapAdvertisingParams::ADV_CONNECTABLE_UNDIRECTED) {
valeyev 0:e056ac8fecf8 216 * return;
valeyev 0:e056ac8fecf8 217 * }
valeyev 0:e056ac8fecf8 218 *
valeyev 0:e056ac8fecf8 219 * // register connection event handler
valeyev 0:e056ac8fecf8 220 * gap.onConnection(handle_connection);
valeyev 0:e056ac8fecf8 221 *
valeyev 0:e056ac8fecf8 222 * Gap::ConnectionParams_t connection_parameters = {
valeyev 0:e056ac8fecf8 223 * 50, // min connection interval
valeyev 0:e056ac8fecf8 224 * 100, // max connection interval
valeyev 0:e056ac8fecf8 225 * 0, // slave latency
valeyev 0:e056ac8fecf8 226 * 600 // connection supervision timeout
valeyev 0:e056ac8fecf8 227 * };
valeyev 0:e056ac8fecf8 228 *
valeyev 0:e056ac8fecf8 229 * // scan parameter used to find the device to connect to
valeyev 0:e056ac8fecf8 230 * GapScanningParams scanning_params(
valeyev 0:e056ac8fecf8 231 * 100, // interval
valeyev 0:e056ac8fecf8 232 * 100, // window
valeyev 0:e056ac8fecf8 233 * 0, // timeout
valeyev 0:e056ac8fecf8 234 * false // active
valeyev 0:e056ac8fecf8 235 * );
valeyev 0:e056ac8fecf8 236 *
valeyev 0:e056ac8fecf8 237 * // Initiate the connection procedure
valeyev 0:e056ac8fecf8 238 * gap.connect(
valeyev 0:e056ac8fecf8 239 * packet->peerAddr,
valeyev 0:e056ac8fecf8 240 * packet->addressType,
valeyev 0:e056ac8fecf8 241 * &connection_parameters,
valeyev 0:e056ac8fecf8 242 * &scanning_params
valeyev 0:e056ac8fecf8 243 * );
valeyev 0:e056ac8fecf8 244 * }
valeyev 0:e056ac8fecf8 245 *
valeyev 0:e056ac8fecf8 246 * // set the scan parameters
valeyev 0:e056ac8fecf8 247 * gap.setScanParams(
valeyev 0:e056ac8fecf8 248 * 100, // interval between two scan window in ms
valeyev 0:e056ac8fecf8 249 * 50, // scan window: period during which the device listen for advertising packets.
valeyev 0:e056ac8fecf8 250 * 0, // the scan process never ends
valeyev 0:e056ac8fecf8 251 * true // the device sends scan request to scannable peers.
valeyev 0:e056ac8fecf8 252 * );
valeyev 0:e056ac8fecf8 253 *
valeyev 0:e056ac8fecf8 254 * // start the scan procedure
valeyev 0:e056ac8fecf8 255 * gap.startScan(handle_advertising_packet);
valeyev 0:e056ac8fecf8 256 * @endcode
valeyev 0:e056ac8fecf8 257 *
valeyev 0:e056ac8fecf8 258 * @par disconnection
valeyev 0:e056ac8fecf8 259 *
valeyev 0:e056ac8fecf8 260 * The application code initiates a disconnection when it calls the
valeyev 0:e056ac8fecf8 261 * disconnect(Handle_t, DisconnectionReason_t) function.
valeyev 0:e056ac8fecf8 262 *
valeyev 0:e056ac8fecf8 263 * Disconnection may also be initiated by the remote peer or the local
valeyev 0:e056ac8fecf8 264 * controller/stack. To catch all disconnection events, application code may
valeyev 0:e056ac8fecf8 265 * set up an handler taking care of disconnection events by calling
valeyev 0:e056ac8fecf8 266 * onDisconnection().
valeyev 0:e056ac8fecf8 267 */
valeyev 0:e056ac8fecf8 268 class Gap {
valeyev 0:e056ac8fecf8 269 /*
valeyev 0:e056ac8fecf8 270 * DEPRECATION ALERT: all of the APIs in this `public` block are deprecated.
valeyev 0:e056ac8fecf8 271 * They have been relocated to the class BLEProtocol.
valeyev 0:e056ac8fecf8 272 */
valeyev 0:e056ac8fecf8 273 public:
valeyev 0:e056ac8fecf8 274 /**
valeyev 0:e056ac8fecf8 275 * Address-type for BLEProtocol addresses.
valeyev 0:e056ac8fecf8 276 *
valeyev 0:e056ac8fecf8 277 * @deprecated Use BLEProtocol::AddressType_t instead.
valeyev 0:e056ac8fecf8 278 */
valeyev 0:e056ac8fecf8 279 typedef BLEProtocol::AddressType_t AddressType_t;
valeyev 0:e056ac8fecf8 280
valeyev 0:e056ac8fecf8 281 /**
valeyev 0:e056ac8fecf8 282 * Address-type for BLEProtocol addresses.
valeyev 0:e056ac8fecf8 283 *
valeyev 0:e056ac8fecf8 284 * @deprecated Use BLEProtocol::AddressType_t instead.
valeyev 0:e056ac8fecf8 285 */
valeyev 0:e056ac8fecf8 286 typedef BLEProtocol::AddressType_t addr_type_t;
valeyev 0:e056ac8fecf8 287
valeyev 0:e056ac8fecf8 288 /**
valeyev 0:e056ac8fecf8 289 * Address-type for BLEProtocol addresses.
valeyev 0:e056ac8fecf8 290 *
valeyev 0:e056ac8fecf8 291 * @deprecated Use BLEProtocol::AddressType_t instead. The following
valeyev 0:e056ac8fecf8 292 * constants have been left in their deprecated state to transparently
valeyev 0:e056ac8fecf8 293 * support existing applications that may have used Gap::ADDR_TYPE_*.
valeyev 0:e056ac8fecf8 294 */
valeyev 0:e056ac8fecf8 295 enum DeprecatedAddressType_t {
valeyev 0:e056ac8fecf8 296 ADDR_TYPE_PUBLIC = BLEProtocol::AddressType::PUBLIC,
valeyev 0:e056ac8fecf8 297 ADDR_TYPE_RANDOM_STATIC = BLEProtocol::AddressType::RANDOM_STATIC,
valeyev 0:e056ac8fecf8 298 ADDR_TYPE_RANDOM_PRIVATE_RESOLVABLE = BLEProtocol::AddressType::RANDOM_PRIVATE_RESOLVABLE,
valeyev 0:e056ac8fecf8 299 ADDR_TYPE_RANDOM_PRIVATE_NON_RESOLVABLE = BLEProtocol::AddressType::RANDOM_PRIVATE_NON_RESOLVABLE
valeyev 0:e056ac8fecf8 300 };
valeyev 0:e056ac8fecf8 301
valeyev 0:e056ac8fecf8 302 /**
valeyev 0:e056ac8fecf8 303 * Length (in octets) of the BLE MAC address.
valeyev 0:e056ac8fecf8 304 */
valeyev 0:e056ac8fecf8 305 static const unsigned ADDR_LEN = BLEProtocol::ADDR_LEN;
valeyev 0:e056ac8fecf8 306
valeyev 0:e056ac8fecf8 307 /**
valeyev 0:e056ac8fecf8 308 * 48-bit address, LSB format.
valeyev 0:e056ac8fecf8 309 *
valeyev 0:e056ac8fecf8 310 * @deprecated Use BLEProtocol::AddressBytes_t instead.
valeyev 0:e056ac8fecf8 311 */
valeyev 0:e056ac8fecf8 312 typedef BLEProtocol::AddressBytes_t Address_t;
valeyev 0:e056ac8fecf8 313
valeyev 0:e056ac8fecf8 314 /**
valeyev 0:e056ac8fecf8 315 * 48-bit address, LSB format.
valeyev 0:e056ac8fecf8 316 *
valeyev 0:e056ac8fecf8 317 * @deprecated Use BLEProtocol::AddressBytes_t instead.
valeyev 0:e056ac8fecf8 318 */
valeyev 0:e056ac8fecf8 319 typedef BLEProtocol::AddressBytes_t address_t;
valeyev 0:e056ac8fecf8 320
valeyev 0:e056ac8fecf8 321 public:
valeyev 0:e056ac8fecf8 322 /**
valeyev 0:e056ac8fecf8 323 * Enumeration of possible timeout sources.
valeyev 0:e056ac8fecf8 324 */
valeyev 0:e056ac8fecf8 325 enum TimeoutSource_t {
valeyev 0:e056ac8fecf8 326 /**
valeyev 0:e056ac8fecf8 327 * Advertising timeout.
valeyev 0:e056ac8fecf8 328 */
valeyev 0:e056ac8fecf8 329 TIMEOUT_SRC_ADVERTISING = 0x00,
valeyev 0:e056ac8fecf8 330
valeyev 0:e056ac8fecf8 331 /**
valeyev 0:e056ac8fecf8 332 * Security request timeout.
valeyev 0:e056ac8fecf8 333 */
valeyev 0:e056ac8fecf8 334 TIMEOUT_SRC_SECURITY_REQUEST = 0x01,
valeyev 0:e056ac8fecf8 335
valeyev 0:e056ac8fecf8 336 /**
valeyev 0:e056ac8fecf8 337 * Scanning timeout.
valeyev 0:e056ac8fecf8 338 */
valeyev 0:e056ac8fecf8 339 TIMEOUT_SRC_SCAN = 0x02,
valeyev 0:e056ac8fecf8 340
valeyev 0:e056ac8fecf8 341 /**
valeyev 0:e056ac8fecf8 342 * Connection timeout.
valeyev 0:e056ac8fecf8 343 */
valeyev 0:e056ac8fecf8 344 TIMEOUT_SRC_CONN = 0x03,
valeyev 0:e056ac8fecf8 345 };
valeyev 0:e056ac8fecf8 346
valeyev 0:e056ac8fecf8 347 /**
valeyev 0:e056ac8fecf8 348 * Enumeration of disconnection reasons.
valeyev 0:e056ac8fecf8 349 *
valeyev 0:e056ac8fecf8 350 * @attention There might be a mismatch between the disconnection reason
valeyev 0:e056ac8fecf8 351 * passed to disconnect() and the disconnection event generated locally
valeyev 0:e056ac8fecf8 352 * because the disconnection reason passed to disconnect() is the
valeyev 0:e056ac8fecf8 353 * disconnection reason to be transmitted to the peer.
valeyev 0:e056ac8fecf8 354 */
valeyev 0:e056ac8fecf8 355 enum DisconnectionReason_t {
valeyev 0:e056ac8fecf8 356 /**
valeyev 0:e056ac8fecf8 357 * The connection timed out.
valeyev 0:e056ac8fecf8 358 *
valeyev 0:e056ac8fecf8 359 * @attention shall not be used as a reason in disconnect().
valeyev 0:e056ac8fecf8 360 */
valeyev 0:e056ac8fecf8 361 CONNECTION_TIMEOUT = 0x08,
valeyev 0:e056ac8fecf8 362
valeyev 0:e056ac8fecf8 363 /**
valeyev 0:e056ac8fecf8 364 * Connection terminated by the user.
valeyev 0:e056ac8fecf8 365 */
valeyev 0:e056ac8fecf8 366 REMOTE_USER_TERMINATED_CONNECTION = 0x13,
valeyev 0:e056ac8fecf8 367
valeyev 0:e056ac8fecf8 368 /**
valeyev 0:e056ac8fecf8 369 * Remote device terminated connection due to low resources.
valeyev 0:e056ac8fecf8 370 */
valeyev 0:e056ac8fecf8 371 REMOTE_DEV_TERMINATION_DUE_TO_LOW_RESOURCES = 0x14,
valeyev 0:e056ac8fecf8 372
valeyev 0:e056ac8fecf8 373 /**
valeyev 0:e056ac8fecf8 374 * Remote device terminated connection due to power off.
valeyev 0:e056ac8fecf8 375 */
valeyev 0:e056ac8fecf8 376 REMOTE_DEV_TERMINATION_DUE_TO_POWER_OFF = 0x15,
valeyev 0:e056ac8fecf8 377
valeyev 0:e056ac8fecf8 378 /**
valeyev 0:e056ac8fecf8 379 * Indicate that the local user or the internal
valeyev 0:e056ac8fecf8 380 * Bluetooth subsystem terminated the connection.
valeyev 0:e056ac8fecf8 381 *
valeyev 0:e056ac8fecf8 382 * @attention shall not be used as a reason in disconnect().
valeyev 0:e056ac8fecf8 383 */
valeyev 0:e056ac8fecf8 384 LOCAL_HOST_TERMINATED_CONNECTION = 0x16,
valeyev 0:e056ac8fecf8 385
valeyev 0:e056ac8fecf8 386 /**
valeyev 0:e056ac8fecf8 387 * Connection parameters were unacceptable.
valeyev 0:e056ac8fecf8 388 */
valeyev 0:e056ac8fecf8 389 CONN_INTERVAL_UNACCEPTABLE = 0x3B,
valeyev 0:e056ac8fecf8 390 };
valeyev 0:e056ac8fecf8 391
valeyev 0:e056ac8fecf8 392 /**
valeyev 0:e056ac8fecf8 393 * Advertising policy filter modes.
valeyev 0:e056ac8fecf8 394 *
valeyev 0:e056ac8fecf8 395 * @see Bluetooth Core Specification 4.2 (Vol. 6), Part B, Section 4.3.2.
valeyev 0:e056ac8fecf8 396 */
valeyev 0:e056ac8fecf8 397 enum AdvertisingPolicyMode_t {
valeyev 0:e056ac8fecf8 398 /**
valeyev 0:e056ac8fecf8 399 * The whitelist is not used to filter peer request during advertising.
valeyev 0:e056ac8fecf8 400 */
valeyev 0:e056ac8fecf8 401 ADV_POLICY_IGNORE_WHITELIST = 0,
valeyev 0:e056ac8fecf8 402
valeyev 0:e056ac8fecf8 403 /**
valeyev 0:e056ac8fecf8 404 * The whitelist is used to filter peer scan requests.
valeyev 0:e056ac8fecf8 405 */
valeyev 0:e056ac8fecf8 406 ADV_POLICY_FILTER_SCAN_REQS = 1,
valeyev 0:e056ac8fecf8 407
valeyev 0:e056ac8fecf8 408 /**
valeyev 0:e056ac8fecf8 409 * The whitelist is used to filter peer connection requests.
valeyev 0:e056ac8fecf8 410 */
valeyev 0:e056ac8fecf8 411 ADV_POLICY_FILTER_CONN_REQS = 2,
valeyev 0:e056ac8fecf8 412
valeyev 0:e056ac8fecf8 413 /**
valeyev 0:e056ac8fecf8 414 * The whitelist is used to filter peer scan and connection requests.
valeyev 0:e056ac8fecf8 415 */
valeyev 0:e056ac8fecf8 416 ADV_POLICY_FILTER_ALL_REQS = 3,
valeyev 0:e056ac8fecf8 417 };
valeyev 0:e056ac8fecf8 418
valeyev 0:e056ac8fecf8 419 /**
valeyev 0:e056ac8fecf8 420 * Scanning policy filter mode.
valeyev 0:e056ac8fecf8 421 *
valeyev 0:e056ac8fecf8 422 * @see Bluetooth Core Specification 4.2 (Vol. 6), Part B, Section 4.3.3.
valeyev 0:e056ac8fecf8 423 */
valeyev 0:e056ac8fecf8 424 enum ScanningPolicyMode_t {
valeyev 0:e056ac8fecf8 425 /**
valeyev 0:e056ac8fecf8 426 * The whitelist is not used for scanning operations.
valeyev 0:e056ac8fecf8 427 */
valeyev 0:e056ac8fecf8 428 SCAN_POLICY_IGNORE_WHITELIST = 0,
valeyev 0:e056ac8fecf8 429
valeyev 0:e056ac8fecf8 430 /**
valeyev 0:e056ac8fecf8 431 * The whitelist is used to filter incoming advertising.
valeyev 0:e056ac8fecf8 432 */
valeyev 0:e056ac8fecf8 433 SCAN_POLICY_FILTER_ALL_ADV = 1,
valeyev 0:e056ac8fecf8 434 };
valeyev 0:e056ac8fecf8 435
valeyev 0:e056ac8fecf8 436 /**
valeyev 0:e056ac8fecf8 437 * Connection initiation policy filter mode.
valeyev 0:e056ac8fecf8 438 *
valeyev 0:e056ac8fecf8 439 * @see Bluetooth Core Specification 4.2 (vol. 6), Part B, Section 4.4.4.
valeyev 0:e056ac8fecf8 440 */
valeyev 0:e056ac8fecf8 441 enum InitiatorPolicyMode_t {
valeyev 0:e056ac8fecf8 442 /**
valeyev 0:e056ac8fecf8 443 * Connection can be initiated to any device.
valeyev 0:e056ac8fecf8 444 */
valeyev 0:e056ac8fecf8 445 INIT_POLICY_IGNORE_WHITELIST = 0,
valeyev 0:e056ac8fecf8 446
valeyev 0:e056ac8fecf8 447 /**
valeyev 0:e056ac8fecf8 448 * Connection initiation is restricted to the devices present in the
valeyev 0:e056ac8fecf8 449 * whitelist.
valeyev 0:e056ac8fecf8 450 */
valeyev 0:e056ac8fecf8 451 INIT_POLICY_FILTER_ALL_ADV = 1,
valeyev 0:e056ac8fecf8 452 };
valeyev 0:e056ac8fecf8 453
valeyev 0:e056ac8fecf8 454 /**
valeyev 0:e056ac8fecf8 455 * Representation of a whitelist of addresses.
valeyev 0:e056ac8fecf8 456 */
valeyev 0:e056ac8fecf8 457 struct Whitelist_t {
valeyev 0:e056ac8fecf8 458 /**
valeyev 0:e056ac8fecf8 459 * Pointer to the array of the addresses composing the whitelist.
valeyev 0:e056ac8fecf8 460 */
valeyev 0:e056ac8fecf8 461 BLEProtocol::Address_t *addresses;
valeyev 0:e056ac8fecf8 462
valeyev 0:e056ac8fecf8 463 /**
valeyev 0:e056ac8fecf8 464 * Number addresses in this whitelist.
valeyev 0:e056ac8fecf8 465 */
valeyev 0:e056ac8fecf8 466 uint8_t size;
valeyev 0:e056ac8fecf8 467
valeyev 0:e056ac8fecf8 468 /**
valeyev 0:e056ac8fecf8 469 * Capacity of the array holding the addresses.
valeyev 0:e056ac8fecf8 470 */
valeyev 0:e056ac8fecf8 471 uint8_t capacity;
valeyev 0:e056ac8fecf8 472 };
valeyev 0:e056ac8fecf8 473
valeyev 0:e056ac8fecf8 474 /**
valeyev 0:e056ac8fecf8 475 * Description of the states of the device.
valeyev 0:e056ac8fecf8 476 */
valeyev 0:e056ac8fecf8 477 struct GapState_t {
valeyev 0:e056ac8fecf8 478 /**
valeyev 0:e056ac8fecf8 479 * If set, the device is currently advertising.
valeyev 0:e056ac8fecf8 480 */
valeyev 0:e056ac8fecf8 481 unsigned advertising : 1;
valeyev 0:e056ac8fecf8 482
valeyev 0:e056ac8fecf8 483 /**
valeyev 0:e056ac8fecf8 484 * If set, the device is connected to at least one other peer.
valeyev 0:e056ac8fecf8 485 */
valeyev 0:e056ac8fecf8 486 unsigned connected : 1;
valeyev 0:e056ac8fecf8 487 };
valeyev 0:e056ac8fecf8 488
valeyev 0:e056ac8fecf8 489 /**
valeyev 0:e056ac8fecf8 490 * Opaque value type representing a connection handle.
valeyev 0:e056ac8fecf8 491 *
valeyev 0:e056ac8fecf8 492 * It is used to identify to refer to a specific connection across Gap,
valeyev 0:e056ac8fecf8 493 * GattClient and GattEvent API.
valeyev 0:e056ac8fecf8 494 *
valeyev 0:e056ac8fecf8 495 * @note instances are generated by in the connection callback.
valeyev 0:e056ac8fecf8 496 */
valeyev 0:e056ac8fecf8 497 typedef ble::connection_handle_t Handle_t;
valeyev 0:e056ac8fecf8 498
valeyev 0:e056ac8fecf8 499 /**
valeyev 0:e056ac8fecf8 500 * Parameters of a BLE connection.
valeyev 0:e056ac8fecf8 501 */
valeyev 0:e056ac8fecf8 502 typedef struct {
valeyev 0:e056ac8fecf8 503 /**
valeyev 0:e056ac8fecf8 504 * Minimum interval between two connection events allowed for a
valeyev 0:e056ac8fecf8 505 * connection.
valeyev 0:e056ac8fecf8 506 *
valeyev 0:e056ac8fecf8 507 * It shall be less than or equal to maxConnectionInterval. This value,
valeyev 0:e056ac8fecf8 508 * in units of 1.25ms, is included in the range [0x0006 : 0x0C80].
valeyev 0:e056ac8fecf8 509 */
valeyev 0:e056ac8fecf8 510 uint16_t minConnectionInterval;
valeyev 0:e056ac8fecf8 511
valeyev 0:e056ac8fecf8 512 /**
valeyev 0:e056ac8fecf8 513 * Maximum interval between two connection events allowed for a
valeyev 0:e056ac8fecf8 514 * connection.
valeyev 0:e056ac8fecf8 515 *
valeyev 0:e056ac8fecf8 516 * It shall be greater than or equal to minConnectionInterval. This
valeyev 0:e056ac8fecf8 517 * value is in unit of 1.25ms and is in the range [0x0006 : 0x0C80].
valeyev 0:e056ac8fecf8 518 */
valeyev 0:e056ac8fecf8 519 uint16_t maxConnectionInterval;
valeyev 0:e056ac8fecf8 520
valeyev 0:e056ac8fecf8 521 /**
valeyev 0:e056ac8fecf8 522 * Number of connection events the slave can drop if it has nothing to
valeyev 0:e056ac8fecf8 523 * communicate to the master.
valeyev 0:e056ac8fecf8 524 *
valeyev 0:e056ac8fecf8 525 * This value shall be in the range [0x0000 : 0x01F3].
valeyev 0:e056ac8fecf8 526 */
valeyev 0:e056ac8fecf8 527 uint16_t slaveLatency;
valeyev 0:e056ac8fecf8 528
valeyev 0:e056ac8fecf8 529 /**
valeyev 0:e056ac8fecf8 530 * Link supervision timeout for the connection.
valeyev 0:e056ac8fecf8 531 *
valeyev 0:e056ac8fecf8 532 * Time after which the connection is considered lost if the device
valeyev 0:e056ac8fecf8 533 * didn't receive a packet from its peer.
valeyev 0:e056ac8fecf8 534 *
valeyev 0:e056ac8fecf8 535 * It is larger than:
valeyev 0:e056ac8fecf8 536 * (1 + slaveLatency) * maxConnectionInterval * 2
valeyev 0:e056ac8fecf8 537 *
valeyev 0:e056ac8fecf8 538 * This value is in the range [0x000A : 0x0C80] and is in unit of
valeyev 0:e056ac8fecf8 539 * 10 ms.
valeyev 0:e056ac8fecf8 540 *
valeyev 0:e056ac8fecf8 541 * @note maxConnectionInterval is in ms in the formulae above.
valeyev 0:e056ac8fecf8 542 */
valeyev 0:e056ac8fecf8 543 uint16_t connectionSupervisionTimeout;
valeyev 0:e056ac8fecf8 544 } ConnectionParams_t;
valeyev 0:e056ac8fecf8 545
valeyev 0:e056ac8fecf8 546 /**
valeyev 0:e056ac8fecf8 547 * Enumeration of GAP roles.
valeyev 0:e056ac8fecf8 548 *
valeyev 0:e056ac8fecf8 549 * @note The BLE API does not express the broadcaster and scanner roles.
valeyev 0:e056ac8fecf8 550 *
valeyev 0:e056ac8fecf8 551 * @attention A device can fulfill different roles concurrently.
valeyev 0:e056ac8fecf8 552 */
valeyev 0:e056ac8fecf8 553 enum Role_t {
valeyev 0:e056ac8fecf8 554 /**
valeyev 0:e056ac8fecf8 555 * Peripheral Role.
valeyev 0:e056ac8fecf8 556 *
valeyev 0:e056ac8fecf8 557 * The device can advertise and it can be connected by a central. It
valeyev 0:e056ac8fecf8 558 * acts as a slave when connected.
valeyev 0:e056ac8fecf8 559 *
valeyev 0:e056ac8fecf8 560 * @note A peripheral is a broadcaster.
valeyev 0:e056ac8fecf8 561 */
valeyev 0:e056ac8fecf8 562 PERIPHERAL = 0x1,
valeyev 0:e056ac8fecf8 563
valeyev 0:e056ac8fecf8 564 /**
valeyev 0:e056ac8fecf8 565 * Central Role.
valeyev 0:e056ac8fecf8 566 *
valeyev 0:e056ac8fecf8 567 * The device can scan and initiate connection to peripherals. It
valeyev 0:e056ac8fecf8 568 * acts as the master when a connection is established.
valeyev 0:e056ac8fecf8 569 *
valeyev 0:e056ac8fecf8 570 * @note A central is a scanner.
valeyev 0:e056ac8fecf8 571 */
valeyev 0:e056ac8fecf8 572 CENTRAL = 0x2,
valeyev 0:e056ac8fecf8 573 };
valeyev 0:e056ac8fecf8 574
valeyev 0:e056ac8fecf8 575 /**
valeyev 0:e056ac8fecf8 576 * Representation of a scanned advertising packet.
valeyev 0:e056ac8fecf8 577 *
valeyev 0:e056ac8fecf8 578 * Instances of this type are passed to the callback registered in
valeyev 0:e056ac8fecf8 579 * startScan().
valeyev 0:e056ac8fecf8 580 */
valeyev 0:e056ac8fecf8 581 struct AdvertisementCallbackParams_t {
valeyev 0:e056ac8fecf8 582 /**
valeyev 0:e056ac8fecf8 583 * BLE address of the device that has advertised the packet.
valeyev 0:e056ac8fecf8 584 */
valeyev 0:e056ac8fecf8 585 BLEProtocol::AddressBytes_t peerAddr;
valeyev 0:e056ac8fecf8 586
valeyev 0:e056ac8fecf8 587 /**
valeyev 0:e056ac8fecf8 588 * RSSI value of the packet.
valeyev 0:e056ac8fecf8 589 */
valeyev 0:e056ac8fecf8 590 int8_t rssi;
valeyev 0:e056ac8fecf8 591
valeyev 0:e056ac8fecf8 592 /**
valeyev 0:e056ac8fecf8 593 * Flag indicating if the packet is a response to a scan request.
valeyev 0:e056ac8fecf8 594 */
valeyev 0:e056ac8fecf8 595 bool isScanResponse;
valeyev 0:e056ac8fecf8 596
valeyev 0:e056ac8fecf8 597 /**
valeyev 0:e056ac8fecf8 598 * Type of advertisement.
valeyev 0:e056ac8fecf8 599 */
valeyev 0:e056ac8fecf8 600 GapAdvertisingParams::AdvertisingType_t type;
valeyev 0:e056ac8fecf8 601
valeyev 0:e056ac8fecf8 602 /**
valeyev 0:e056ac8fecf8 603 * Length of the advertisement data.
valeyev 0:e056ac8fecf8 604 */
valeyev 0:e056ac8fecf8 605 uint8_t advertisingDataLen;
valeyev 0:e056ac8fecf8 606
valeyev 0:e056ac8fecf8 607 /**
valeyev 0:e056ac8fecf8 608 * Pointer to the advertisement packet's data.
valeyev 0:e056ac8fecf8 609 */
valeyev 0:e056ac8fecf8 610 const uint8_t *advertisingData;
valeyev 0:e056ac8fecf8 611
valeyev 0:e056ac8fecf8 612 /**
valeyev 0:e056ac8fecf8 613 * Type of the address received
valeyev 0:e056ac8fecf8 614 */
valeyev 0:e056ac8fecf8 615 AddressType_t addressType;
valeyev 0:e056ac8fecf8 616 };
valeyev 0:e056ac8fecf8 617
valeyev 0:e056ac8fecf8 618 /**
valeyev 0:e056ac8fecf8 619 * Type of the callback handling scanned advertisement packets.
valeyev 0:e056ac8fecf8 620 *
valeyev 0:e056ac8fecf8 621 * @see Gap::startScan().
valeyev 0:e056ac8fecf8 622 */
valeyev 0:e056ac8fecf8 623 typedef FunctionPointerWithContext<const AdvertisementCallbackParams_t *>
valeyev 0:e056ac8fecf8 624 AdvertisementReportCallback_t;
valeyev 0:e056ac8fecf8 625
valeyev 0:e056ac8fecf8 626 /**
valeyev 0:e056ac8fecf8 627 * Connection events.
valeyev 0:e056ac8fecf8 628 *
valeyev 0:e056ac8fecf8 629 * It contains all the information related to a newly established connection.
valeyev 0:e056ac8fecf8 630 *
valeyev 0:e056ac8fecf8 631 * Instances of this structure are passed to handlers that
valeyev 0:e056ac8fecf8 632 * Gap::onConnection() registers when a connection is established.
valeyev 0:e056ac8fecf8 633 */
valeyev 0:e056ac8fecf8 634 struct ConnectionCallbackParams_t {
valeyev 0:e056ac8fecf8 635 /**
valeyev 0:e056ac8fecf8 636 * Connection handle.
valeyev 0:e056ac8fecf8 637 */
valeyev 0:e056ac8fecf8 638 Handle_t handle;
valeyev 0:e056ac8fecf8 639
valeyev 0:e056ac8fecf8 640 /**
valeyev 0:e056ac8fecf8 641 * Connection Role of the local device.
valeyev 0:e056ac8fecf8 642 */
valeyev 0:e056ac8fecf8 643 Role_t role;
valeyev 0:e056ac8fecf8 644
valeyev 0:e056ac8fecf8 645 /**
valeyev 0:e056ac8fecf8 646 * Type of the address the peer uses.
valeyev 0:e056ac8fecf8 647 */
valeyev 0:e056ac8fecf8 648 BLEProtocol::AddressType_t peerAddrType;
valeyev 0:e056ac8fecf8 649
valeyev 0:e056ac8fecf8 650 /**
valeyev 0:e056ac8fecf8 651 * Address of the peer.
valeyev 0:e056ac8fecf8 652 */
valeyev 0:e056ac8fecf8 653 BLEProtocol::AddressBytes_t peerAddr;
valeyev 0:e056ac8fecf8 654
valeyev 0:e056ac8fecf8 655 /**
valeyev 0:e056ac8fecf8 656 * Address type of the local device.
valeyev 0:e056ac8fecf8 657 */
valeyev 0:e056ac8fecf8 658 BLEProtocol::AddressType_t ownAddrType;
valeyev 0:e056ac8fecf8 659
valeyev 0:e056ac8fecf8 660 /**
valeyev 0:e056ac8fecf8 661 * Address of the local device.
valeyev 0:e056ac8fecf8 662 */
valeyev 0:e056ac8fecf8 663 BLEProtocol::AddressBytes_t ownAddr;
valeyev 0:e056ac8fecf8 664
valeyev 0:e056ac8fecf8 665 /**
valeyev 0:e056ac8fecf8 666 * Connection parameters.
valeyev 0:e056ac8fecf8 667 */
valeyev 0:e056ac8fecf8 668 const ConnectionParams_t *connectionParams;
valeyev 0:e056ac8fecf8 669
valeyev 0:e056ac8fecf8 670 /**
valeyev 0:e056ac8fecf8 671 * Construct an instance of ConnectionCallbackParams_t.
valeyev 0:e056ac8fecf8 672 *
valeyev 0:e056ac8fecf8 673 * @param[in] handleIn Value to assign to handle.
valeyev 0:e056ac8fecf8 674 * @param[in] roleIn Value to assign to role.
valeyev 0:e056ac8fecf8 675 * @param[in] peerAddrTypeIn Value to assign to peerAddrType.
valeyev 0:e056ac8fecf8 676 * @param[in] peerAddrIn Value to assign to peerAddr.
valeyev 0:e056ac8fecf8 677 * @param[in] ownAddrTypeIn Value to assign to ownAddrType.
valeyev 0:e056ac8fecf8 678 * @param[in] ownAddrIn Value to assign to ownAddr.
valeyev 0:e056ac8fecf8 679 * @param[in] connectionParamsIn Value to assign to connectionParams.
valeyev 0:e056ac8fecf8 680 *
valeyev 0:e056ac8fecf8 681 * @note Constructor is not meant to be called by user code.
valeyev 0:e056ac8fecf8 682 * The BLE API vendor code generates ConnectionCallbackParams_t.
valeyev 0:e056ac8fecf8 683 */
valeyev 0:e056ac8fecf8 684 ConnectionCallbackParams_t(
valeyev 0:e056ac8fecf8 685 Handle_t handleIn,
valeyev 0:e056ac8fecf8 686 Role_t roleIn,
valeyev 0:e056ac8fecf8 687 BLEProtocol::AddressType_t peerAddrTypeIn,
valeyev 0:e056ac8fecf8 688 const uint8_t *peerAddrIn,
valeyev 0:e056ac8fecf8 689 BLEProtocol::AddressType_t ownAddrTypeIn,
valeyev 0:e056ac8fecf8 690 const uint8_t *ownAddrIn,
valeyev 0:e056ac8fecf8 691 const ConnectionParams_t *connectionParamsIn
valeyev 0:e056ac8fecf8 692 ) : handle(handleIn),
valeyev 0:e056ac8fecf8 693 role(roleIn),
valeyev 0:e056ac8fecf8 694 peerAddrType(peerAddrTypeIn),
valeyev 0:e056ac8fecf8 695 peerAddr(),
valeyev 0:e056ac8fecf8 696 ownAddrType(ownAddrTypeIn),
valeyev 0:e056ac8fecf8 697 ownAddr(),
valeyev 0:e056ac8fecf8 698 connectionParams(connectionParamsIn)
valeyev 0:e056ac8fecf8 699 {
valeyev 0:e056ac8fecf8 700 memcpy(peerAddr, peerAddrIn, ADDR_LEN);
valeyev 0:e056ac8fecf8 701 memcpy(ownAddr, ownAddrIn, ADDR_LEN);
valeyev 0:e056ac8fecf8 702 }
valeyev 0:e056ac8fecf8 703 };
valeyev 0:e056ac8fecf8 704
valeyev 0:e056ac8fecf8 705 /**
valeyev 0:e056ac8fecf8 706 * Disconnection event.
valeyev 0:e056ac8fecf8 707 *
valeyev 0:e056ac8fecf8 708 * Instances of this event are passed to callbacks registered with
valeyev 0:e056ac8fecf8 709 * Gap::onDisconnection() when a connection ends.
valeyev 0:e056ac8fecf8 710 *
valeyev 0:e056ac8fecf8 711 * @note Constructor is not meant to be called by user code.
valeyev 0:e056ac8fecf8 712 * The BLE API vendor code generates ConnectionCallbackParams_t.
valeyev 0:e056ac8fecf8 713 */
valeyev 0:e056ac8fecf8 714 struct DisconnectionCallbackParams_t {
valeyev 0:e056ac8fecf8 715 /**
valeyev 0:e056ac8fecf8 716 * ID of the connection that has ended.
valeyev 0:e056ac8fecf8 717 */
valeyev 0:e056ac8fecf8 718 Handle_t handle;
valeyev 0:e056ac8fecf8 719
valeyev 0:e056ac8fecf8 720 /**
valeyev 0:e056ac8fecf8 721 * Reason of the disconnection.
valeyev 0:e056ac8fecf8 722 */
valeyev 0:e056ac8fecf8 723 DisconnectionReason_t reason;
valeyev 0:e056ac8fecf8 724
valeyev 0:e056ac8fecf8 725 /**
valeyev 0:e056ac8fecf8 726 * Construct a DisconnectionCallbackParams_t.
valeyev 0:e056ac8fecf8 727 *
valeyev 0:e056ac8fecf8 728 * @param[in] handleIn Value assigned to handle.
valeyev 0:e056ac8fecf8 729 * @param[in] reasonIn Value assigned to reason.
valeyev 0:e056ac8fecf8 730 */
valeyev 0:e056ac8fecf8 731 DisconnectionCallbackParams_t(
valeyev 0:e056ac8fecf8 732 Handle_t handleIn,
valeyev 0:e056ac8fecf8 733 DisconnectionReason_t reasonIn
valeyev 0:e056ac8fecf8 734 ) : handle(handleIn),
valeyev 0:e056ac8fecf8 735 reason(reasonIn)
valeyev 0:e056ac8fecf8 736 {}
valeyev 0:e056ac8fecf8 737 };
valeyev 0:e056ac8fecf8 738
valeyev 0:e056ac8fecf8 739 /**
valeyev 0:e056ac8fecf8 740 * Number of microseconds in 1.25 milliseconds.
valeyev 0:e056ac8fecf8 741 */
valeyev 0:e056ac8fecf8 742 static const uint16_t UNIT_1_25_MS = 1250;
valeyev 0:e056ac8fecf8 743
valeyev 0:e056ac8fecf8 744 /**
valeyev 0:e056ac8fecf8 745 * Convert milliseconds into 1.25ms units.
valeyev 0:e056ac8fecf8 746 *
valeyev 0:e056ac8fecf8 747 * This function may be used to convert ms time of connection intervals into
valeyev 0:e056ac8fecf8 748 * the format expected for connection parameters.
valeyev 0:e056ac8fecf8 749 *
valeyev 0:e056ac8fecf8 750 * @param[in] durationInMillis The duration in milliseconds.
valeyev 0:e056ac8fecf8 751 *
valeyev 0:e056ac8fecf8 752 * @return The duration in unit of 1.25ms.
valeyev 0:e056ac8fecf8 753 */
valeyev 0:e056ac8fecf8 754 static uint16_t MSEC_TO_GAP_DURATION_UNITS(uint32_t durationInMillis)
valeyev 0:e056ac8fecf8 755 {
valeyev 0:e056ac8fecf8 756 return (durationInMillis * 1000) / UNIT_1_25_MS;
valeyev 0:e056ac8fecf8 757 }
valeyev 0:e056ac8fecf8 758
valeyev 0:e056ac8fecf8 759 /**
valeyev 0:e056ac8fecf8 760 * Timeout event handler.
valeyev 0:e056ac8fecf8 761 *
valeyev 0:e056ac8fecf8 762 * @see Gap::onTimeout().
valeyev 0:e056ac8fecf8 763 */
valeyev 0:e056ac8fecf8 764 typedef FunctionPointerWithContext<TimeoutSource_t> TimeoutEventCallback_t;
valeyev 0:e056ac8fecf8 765
valeyev 0:e056ac8fecf8 766 /**
valeyev 0:e056ac8fecf8 767 * Callchain of timeout event handlers.
valeyev 0:e056ac8fecf8 768 *
valeyev 0:e056ac8fecf8 769 * @see Gap::onTimeout().
valeyev 0:e056ac8fecf8 770 */
valeyev 0:e056ac8fecf8 771 typedef CallChainOfFunctionPointersWithContext<TimeoutSource_t>
valeyev 0:e056ac8fecf8 772 TimeoutEventCallbackChain_t;
valeyev 0:e056ac8fecf8 773
valeyev 0:e056ac8fecf8 774 /**
valeyev 0:e056ac8fecf8 775 * Connection event handler.
valeyev 0:e056ac8fecf8 776 *
valeyev 0:e056ac8fecf8 777 * @see Gap::onConnection().
valeyev 0:e056ac8fecf8 778 */
valeyev 0:e056ac8fecf8 779 typedef FunctionPointerWithContext<const ConnectionCallbackParams_t *>
valeyev 0:e056ac8fecf8 780 ConnectionEventCallback_t;
valeyev 0:e056ac8fecf8 781
valeyev 0:e056ac8fecf8 782 /**
valeyev 0:e056ac8fecf8 783 * Callchain of connection event handlers.
valeyev 0:e056ac8fecf8 784 *
valeyev 0:e056ac8fecf8 785 * @see Gap::onConnection().
valeyev 0:e056ac8fecf8 786 */
valeyev 0:e056ac8fecf8 787 typedef CallChainOfFunctionPointersWithContext<const ConnectionCallbackParams_t *>
valeyev 0:e056ac8fecf8 788 ConnectionEventCallbackChain_t;
valeyev 0:e056ac8fecf8 789
valeyev 0:e056ac8fecf8 790 /**
valeyev 0:e056ac8fecf8 791 * Disconnection event handler.
valeyev 0:e056ac8fecf8 792 *
valeyev 0:e056ac8fecf8 793 * @see Gap::onDisconnection().
valeyev 0:e056ac8fecf8 794 */
valeyev 0:e056ac8fecf8 795 typedef FunctionPointerWithContext<const DisconnectionCallbackParams_t*>
valeyev 0:e056ac8fecf8 796 DisconnectionEventCallback_t;
valeyev 0:e056ac8fecf8 797
valeyev 0:e056ac8fecf8 798 /**
valeyev 0:e056ac8fecf8 799 * Callchain of disconnection event handlers.
valeyev 0:e056ac8fecf8 800 *
valeyev 0:e056ac8fecf8 801 * @see Gap::onDisconnection().
valeyev 0:e056ac8fecf8 802 */
valeyev 0:e056ac8fecf8 803 typedef CallChainOfFunctionPointersWithContext<const DisconnectionCallbackParams_t*>
valeyev 0:e056ac8fecf8 804 DisconnectionEventCallbackChain_t;
valeyev 0:e056ac8fecf8 805
valeyev 0:e056ac8fecf8 806 /**
valeyev 0:e056ac8fecf8 807 * Radio notification event handler.
valeyev 0:e056ac8fecf8 808 *
valeyev 0:e056ac8fecf8 809 * @see Gap::onRadioNotification().
valeyev 0:e056ac8fecf8 810 */
valeyev 0:e056ac8fecf8 811 typedef FunctionPointerWithContext<bool> RadioNotificationEventCallback_t;
valeyev 0:e056ac8fecf8 812
valeyev 0:e056ac8fecf8 813 /**
valeyev 0:e056ac8fecf8 814 * Gap shutdown event handler.
valeyev 0:e056ac8fecf8 815 *
valeyev 0:e056ac8fecf8 816 * @see Gap::onShutdown().
valeyev 0:e056ac8fecf8 817 */
valeyev 0:e056ac8fecf8 818 typedef FunctionPointerWithContext<const Gap *> GapShutdownCallback_t;
valeyev 0:e056ac8fecf8 819
valeyev 0:e056ac8fecf8 820 /**
valeyev 0:e056ac8fecf8 821 * Callchain of gap shutdown event handler.
valeyev 0:e056ac8fecf8 822 *
valeyev 0:e056ac8fecf8 823 * @see Gap::onShutdown().
valeyev 0:e056ac8fecf8 824 */
valeyev 0:e056ac8fecf8 825 typedef CallChainOfFunctionPointersWithContext<const Gap *>
valeyev 0:e056ac8fecf8 826 GapShutdownCallbackChain_t;
valeyev 0:e056ac8fecf8 827
valeyev 0:e056ac8fecf8 828 /*
valeyev 0:e056ac8fecf8 829 * The following functions are meant to be overridden in the platform-specific subclass.
valeyev 0:e056ac8fecf8 830 */
valeyev 0:e056ac8fecf8 831 public:
valeyev 0:e056ac8fecf8 832 /**
valeyev 0:e056ac8fecf8 833 * Set the device MAC address and type.
valeyev 0:e056ac8fecf8 834 *
valeyev 0:e056ac8fecf8 835 * The address set is used in subsequent GAP operations: scanning,
valeyev 0:e056ac8fecf8 836 * advertising and connection initiation.
valeyev 0:e056ac8fecf8 837 *
valeyev 0:e056ac8fecf8 838 * @param[in] type Type of the address to set.
valeyev 0:e056ac8fecf8 839 * @param[in] address Value of the address to set. It is ordered in
valeyev 0:e056ac8fecf8 840 * little endian. This parameter is not considered if the address type
valeyev 0:e056ac8fecf8 841 * is RANDOM_PRIVATE_RESOLVABLE or RANDOM_PRIVATE_NON_RESOLVABLE. For those
valeyev 0:e056ac8fecf8 842 * types of address, the BLE API itself generates the address.
valeyev 0:e056ac8fecf8 843 *
valeyev 0:e056ac8fecf8 844 * @note Some implementation may refuse to set a new PUBLIC address.
valeyev 0:e056ac8fecf8 845 * @note Random static address set does not change.
valeyev 0:e056ac8fecf8 846 *
valeyev 0:e056ac8fecf8 847 * @return BLE_ERROR_NONE on success.
valeyev 0:e056ac8fecf8 848 */
valeyev 0:e056ac8fecf8 849 virtual ble_error_t setAddress(
valeyev 0:e056ac8fecf8 850 BLEProtocol::AddressType_t type,
valeyev 0:e056ac8fecf8 851 const BLEProtocol::AddressBytes_t address
valeyev 0:e056ac8fecf8 852 ) {
valeyev 0:e056ac8fecf8 853 /* avoid compiler warnings about unused variables */
valeyev 0:e056ac8fecf8 854 (void)type;
valeyev 0:e056ac8fecf8 855 (void)address;
valeyev 0:e056ac8fecf8 856
valeyev 0:e056ac8fecf8 857 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 858 is supported. */
valeyev 0:e056ac8fecf8 859 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 860 }
valeyev 0:e056ac8fecf8 861
valeyev 0:e056ac8fecf8 862 /**
valeyev 0:e056ac8fecf8 863 * Fetch the current address and its type.
valeyev 0:e056ac8fecf8 864 *
valeyev 0:e056ac8fecf8 865 * @param[out] typeP Type of the current address set.
valeyev 0:e056ac8fecf8 866 * @param[out] address Value of the current address.
valeyev 0:e056ac8fecf8 867 *
valeyev 0:e056ac8fecf8 868 * @return BLE_ERROR_NONE on success.
valeyev 0:e056ac8fecf8 869 */
valeyev 0:e056ac8fecf8 870 virtual ble_error_t getAddress(
valeyev 0:e056ac8fecf8 871 BLEProtocol::AddressType_t *typeP,
valeyev 0:e056ac8fecf8 872 BLEProtocol::AddressBytes_t address
valeyev 0:e056ac8fecf8 873 ) {
valeyev 0:e056ac8fecf8 874 /* Avoid compiler warnings about unused variables. */
valeyev 0:e056ac8fecf8 875 (void)typeP;
valeyev 0:e056ac8fecf8 876 (void)address;
valeyev 0:e056ac8fecf8 877
valeyev 0:e056ac8fecf8 878 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 879 is supported. */
valeyev 0:e056ac8fecf8 880 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 881 }
valeyev 0:e056ac8fecf8 882
valeyev 0:e056ac8fecf8 883 /**
valeyev 0:e056ac8fecf8 884 * Get the minimum advertising interval in milliseconds, which can be used
valeyev 0:e056ac8fecf8 885 * for connectable advertising types.
valeyev 0:e056ac8fecf8 886 *
valeyev 0:e056ac8fecf8 887 * @return Minimum Advertising interval in milliseconds for connectable
valeyev 0:e056ac8fecf8 888 * undirected and connectable directed advertising types.
valeyev 0:e056ac8fecf8 889 */
valeyev 0:e056ac8fecf8 890 virtual uint16_t getMinAdvertisingInterval(void) const
valeyev 0:e056ac8fecf8 891 {
valeyev 0:e056ac8fecf8 892 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 893 is supported. */
valeyev 0:e056ac8fecf8 894 return 0;
valeyev 0:e056ac8fecf8 895 }
valeyev 0:e056ac8fecf8 896
valeyev 0:e056ac8fecf8 897 /**
valeyev 0:e056ac8fecf8 898 * Get the minimum advertising interval in milliseconds, which can be
valeyev 0:e056ac8fecf8 899 * used for nonconnectable advertising type.
valeyev 0:e056ac8fecf8 900 *
valeyev 0:e056ac8fecf8 901 * @return Minimum Advertising interval in milliseconds for scannable
valeyev 0:e056ac8fecf8 902 * undirected and nonconnectable undirected event types.
valeyev 0:e056ac8fecf8 903 */
valeyev 0:e056ac8fecf8 904 virtual uint16_t getMinNonConnectableAdvertisingInterval(void) const
valeyev 0:e056ac8fecf8 905 {
valeyev 0:e056ac8fecf8 906 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 907 is supported. */
valeyev 0:e056ac8fecf8 908 return 0;
valeyev 0:e056ac8fecf8 909 }
valeyev 0:e056ac8fecf8 910
valeyev 0:e056ac8fecf8 911 /**
valeyev 0:e056ac8fecf8 912 * Get the maximum advertising interval in milliseconds.
valeyev 0:e056ac8fecf8 913 *
valeyev 0:e056ac8fecf8 914 * @return Maximum Advertising interval in milliseconds.
valeyev 0:e056ac8fecf8 915 */
valeyev 0:e056ac8fecf8 916 virtual uint16_t getMaxAdvertisingInterval(void) const
valeyev 0:e056ac8fecf8 917 {
valeyev 0:e056ac8fecf8 918 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 919 is supported. */
valeyev 0:e056ac8fecf8 920 return 0xFFFF;
valeyev 0:e056ac8fecf8 921 }
valeyev 0:e056ac8fecf8 922
valeyev 0:e056ac8fecf8 923 /**
valeyev 0:e056ac8fecf8 924 * Stop the ongoing advertising procedure.
valeyev 0:e056ac8fecf8 925 *
valeyev 0:e056ac8fecf8 926 * @note The current advertising parameters remain in effect.
valeyev 0:e056ac8fecf8 927 *
valeyev 0:e056ac8fecf8 928 * @retval BLE_ERROR_NONE if the advertising procedure has been successfully
valeyev 0:e056ac8fecf8 929 * stopped.
valeyev 0:e056ac8fecf8 930 */
valeyev 0:e056ac8fecf8 931 virtual ble_error_t stopAdvertising(void)
valeyev 0:e056ac8fecf8 932 {
valeyev 0:e056ac8fecf8 933 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 934 is supported. */
valeyev 0:e056ac8fecf8 935 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 936 }
valeyev 0:e056ac8fecf8 937
valeyev 0:e056ac8fecf8 938 /**
valeyev 0:e056ac8fecf8 939 * Stop the ongoing scanning procedure.
valeyev 0:e056ac8fecf8 940 *
valeyev 0:e056ac8fecf8 941 * The current scanning parameters remain in effect.
valeyev 0:e056ac8fecf8 942 *
valeyev 0:e056ac8fecf8 943 * @retval BLE_ERROR_NONE if successfully stopped scanning procedure.
valeyev 0:e056ac8fecf8 944 */
valeyev 0:e056ac8fecf8 945 virtual ble_error_t stopScan()
valeyev 0:e056ac8fecf8 946 {
valeyev 0:e056ac8fecf8 947 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 948 is supported. */
valeyev 0:e056ac8fecf8 949 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 950 }
valeyev 0:e056ac8fecf8 951
valeyev 0:e056ac8fecf8 952 /**
valeyev 0:e056ac8fecf8 953 * Initiate a connection to a peer.
valeyev 0:e056ac8fecf8 954 *
valeyev 0:e056ac8fecf8 955 * Once the connection is established, a ConnectionCallbackParams_t event is
valeyev 0:e056ac8fecf8 956 * emitted to handlers that have been registered with onConnection().
valeyev 0:e056ac8fecf8 957 *
valeyev 0:e056ac8fecf8 958 * @param[in] peerAddr MAC address of the peer. It must be in LSB format.
valeyev 0:e056ac8fecf8 959 * @param[in] peerAddrType Address type of the peer.
valeyev 0:e056ac8fecf8 960 * @param[in] connectionParams Connection parameters to use.
valeyev 0:e056ac8fecf8 961 * @param[in] scanParams Scan parameters used to find the peer.
valeyev 0:e056ac8fecf8 962 *
valeyev 0:e056ac8fecf8 963 * @return BLE_ERROR_NONE if connection establishment procedure is started
valeyev 0:e056ac8fecf8 964 * successfully. The connectionCallChain (if set) is invoked upon
valeyev 0:e056ac8fecf8 965 * a connection event.
valeyev 0:e056ac8fecf8 966 */
valeyev 0:e056ac8fecf8 967 virtual ble_error_t connect(
valeyev 0:e056ac8fecf8 968 const BLEProtocol::AddressBytes_t peerAddr,
valeyev 0:e056ac8fecf8 969 BLEProtocol::AddressType_t peerAddrType,
valeyev 0:e056ac8fecf8 970 const ConnectionParams_t *connectionParams,
valeyev 0:e056ac8fecf8 971 const GapScanningParams *scanParams
valeyev 0:e056ac8fecf8 972 ) {
valeyev 0:e056ac8fecf8 973 /* Avoid compiler warnings about unused variables. */
valeyev 0:e056ac8fecf8 974 (void)peerAddr;
valeyev 0:e056ac8fecf8 975 (void)peerAddrType;
valeyev 0:e056ac8fecf8 976 (void)connectionParams;
valeyev 0:e056ac8fecf8 977 (void)scanParams;
valeyev 0:e056ac8fecf8 978
valeyev 0:e056ac8fecf8 979 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 980 is supported. */
valeyev 0:e056ac8fecf8 981 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 982 }
valeyev 0:e056ac8fecf8 983
valeyev 0:e056ac8fecf8 984 /**
valeyev 0:e056ac8fecf8 985 * Initiate a connection to a peer.
valeyev 0:e056ac8fecf8 986 *
valeyev 0:e056ac8fecf8 987 * @see connect()
valeyev 0:e056ac8fecf8 988 *
valeyev 0:e056ac8fecf8 989 * @deprecated This funtion overloads Gap::connect(
valeyev 0:e056ac8fecf8 990 * const BLEProtocol::Address_t peerAddr,
valeyev 0:e056ac8fecf8 991 * BLEProtocol::AddressType_t peerAddrType,
valeyev 0:e056ac8fecf8 992 * const ConnectionParams_t *connectionParams,
valeyev 0:e056ac8fecf8 993 * const GapScanningParams *scanParams
valeyev 0:e056ac8fecf8 994 * )
valeyev 0:e056ac8fecf8 995 * to maintain backward compatibility for changes from Gap::AddressType_t to
valeyev 0:e056ac8fecf8 996 * BLEProtocol::AddressType_t.
valeyev 0:e056ac8fecf8 997 */
valeyev 0:e056ac8fecf8 998 MBED_DEPRECATED("Gap::DeprecatedAddressType_t is deprecated, use BLEProtocol::AddressType_t instead")
valeyev 0:e056ac8fecf8 999 ble_error_t connect(
valeyev 0:e056ac8fecf8 1000 const BLEProtocol::AddressBytes_t peerAddr,
valeyev 0:e056ac8fecf8 1001 DeprecatedAddressType_t peerAddrType,
valeyev 0:e056ac8fecf8 1002 const ConnectionParams_t *connectionParams,
valeyev 0:e056ac8fecf8 1003 const GapScanningParams *scanParams
valeyev 0:e056ac8fecf8 1004 ) {
valeyev 0:e056ac8fecf8 1005 return connect(
valeyev 0:e056ac8fecf8 1006 peerAddr,
valeyev 0:e056ac8fecf8 1007 (BLEProtocol::AddressType_t)
valeyev 0:e056ac8fecf8 1008 peerAddrType,
valeyev 0:e056ac8fecf8 1009 connectionParams,
valeyev 0:e056ac8fecf8 1010 scanParams
valeyev 0:e056ac8fecf8 1011 );
valeyev 0:e056ac8fecf8 1012 }
valeyev 0:e056ac8fecf8 1013
valeyev 0:e056ac8fecf8 1014 /**
valeyev 0:e056ac8fecf8 1015 * Initiate a disconnection procedure.
valeyev 0:e056ac8fecf8 1016 *
valeyev 0:e056ac8fecf8 1017 * Once the disconnection procedure has completed a
valeyev 0:e056ac8fecf8 1018 * DisconnectionCallbackParams_t, the event is emitted to handlers that
valeyev 0:e056ac8fecf8 1019 * have been registered with onDisconnection().
valeyev 0:e056ac8fecf8 1020 *
valeyev 0:e056ac8fecf8 1021 * @param[in] reason Reason of the disconnection transmitted to the peer.
valeyev 0:e056ac8fecf8 1022 * @param[in] connectionHandle Handle of the connection to end.
valeyev 0:e056ac8fecf8 1023 *
valeyev 0:e056ac8fecf8 1024 * @return BLE_ERROR_NONE if the disconnection procedure successfully
valeyev 0:e056ac8fecf8 1025 * started.
valeyev 0:e056ac8fecf8 1026 */
valeyev 0:e056ac8fecf8 1027 virtual ble_error_t disconnect(
valeyev 0:e056ac8fecf8 1028 Handle_t connectionHandle, DisconnectionReason_t reason
valeyev 0:e056ac8fecf8 1029 ) {
valeyev 0:e056ac8fecf8 1030 /* avoid compiler warnings about unused variables */
valeyev 0:e056ac8fecf8 1031 (void)connectionHandle;
valeyev 0:e056ac8fecf8 1032 (void)reason;
valeyev 0:e056ac8fecf8 1033
valeyev 0:e056ac8fecf8 1034 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1035 is supported. */
valeyev 0:e056ac8fecf8 1036 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1037 }
valeyev 0:e056ac8fecf8 1038
valeyev 0:e056ac8fecf8 1039 /**
valeyev 0:e056ac8fecf8 1040 * Initiate a disconnection procedure.
valeyev 0:e056ac8fecf8 1041 *
valeyev 0:e056ac8fecf8 1042 * @deprecated This version of disconnect() doesn't take a connection handle.
valeyev 0:e056ac8fecf8 1043 * It works reliably only for stacks that are limited to a single connection.
valeyev 0:e056ac8fecf8 1044 * Use Gap::disconnect(Handle_t connectionHandle, DisconnectionReason_t reason)
valeyev 0:e056ac8fecf8 1045 * instead.
valeyev 0:e056ac8fecf8 1046 *
valeyev 0:e056ac8fecf8 1047 * @param[in] reason The reason for disconnection; to be sent back to the peer.
valeyev 0:e056ac8fecf8 1048 *
valeyev 0:e056ac8fecf8 1049 * @return BLE_ERROR_NONE if disconnection was successful.
valeyev 0:e056ac8fecf8 1050 */
valeyev 0:e056ac8fecf8 1051 MBED_DEPRECATED("Use disconnect(Handle_t, DisconnectionReason_t) instead.")
valeyev 0:e056ac8fecf8 1052 virtual ble_error_t disconnect(DisconnectionReason_t reason) {
valeyev 0:e056ac8fecf8 1053 /* Avoid compiler warnings about unused variables. */
valeyev 0:e056ac8fecf8 1054 (void)reason;
valeyev 0:e056ac8fecf8 1055
valeyev 0:e056ac8fecf8 1056 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1057 is supported. */
valeyev 0:e056ac8fecf8 1058 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1059 }
valeyev 0:e056ac8fecf8 1060
valeyev 0:e056ac8fecf8 1061 /**
valeyev 0:e056ac8fecf8 1062 * Returned the preferred connection parameters exposed in the GATT Generic
valeyev 0:e056ac8fecf8 1063 * Access Service.
valeyev 0:e056ac8fecf8 1064 *
valeyev 0:e056ac8fecf8 1065 * @param[out] params Structure where the parameters are stored.
valeyev 0:e056ac8fecf8 1066 *
valeyev 0:e056ac8fecf8 1067 * @return BLE_ERROR_NONE if the parameters were successfully filled into
valeyev 0:e056ac8fecf8 1068 * @p params.
valeyev 0:e056ac8fecf8 1069 */
valeyev 0:e056ac8fecf8 1070 virtual ble_error_t getPreferredConnectionParams(ConnectionParams_t *params)
valeyev 0:e056ac8fecf8 1071 {
valeyev 0:e056ac8fecf8 1072 /* Avoid compiler warnings about unused variables. */
valeyev 0:e056ac8fecf8 1073 (void)params;
valeyev 0:e056ac8fecf8 1074
valeyev 0:e056ac8fecf8 1075 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1076 is supported. */
valeyev 0:e056ac8fecf8 1077 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1078 }
valeyev 0:e056ac8fecf8 1079
valeyev 0:e056ac8fecf8 1080 /**
valeyev 0:e056ac8fecf8 1081 * Set the value of the preferred connection parameters exposed in the GATT
valeyev 0:e056ac8fecf8 1082 * Generic Access Service.
valeyev 0:e056ac8fecf8 1083 *
valeyev 0:e056ac8fecf8 1084 * A connected peer may read the characteristic exposing these parameters
valeyev 0:e056ac8fecf8 1085 * and request an update of the connection parameters to accomodate the
valeyev 0:e056ac8fecf8 1086 * local device.
valeyev 0:e056ac8fecf8 1087 *
valeyev 0:e056ac8fecf8 1088 * @param[in] params Value of the preferred connection parameters.
valeyev 0:e056ac8fecf8 1089 *
valeyev 0:e056ac8fecf8 1090 * @return BLE_ERROR_NONE if the preferred connection params were set
valeyev 0:e056ac8fecf8 1091 * correctly.
valeyev 0:e056ac8fecf8 1092 */
valeyev 0:e056ac8fecf8 1093 virtual ble_error_t setPreferredConnectionParams(
valeyev 0:e056ac8fecf8 1094 const ConnectionParams_t *params
valeyev 0:e056ac8fecf8 1095 ) {
valeyev 0:e056ac8fecf8 1096 /* Avoid compiler warnings about unused variables. */
valeyev 0:e056ac8fecf8 1097 (void)params;
valeyev 0:e056ac8fecf8 1098
valeyev 0:e056ac8fecf8 1099 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1100 is supported. */
valeyev 0:e056ac8fecf8 1101 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1102 }
valeyev 0:e056ac8fecf8 1103
valeyev 0:e056ac8fecf8 1104 /**
valeyev 0:e056ac8fecf8 1105 * Update connection parameters of an existing connection.
valeyev 0:e056ac8fecf8 1106 *
valeyev 0:e056ac8fecf8 1107 * In the central role, this initiates a Link Layer connection parameter
valeyev 0:e056ac8fecf8 1108 * update procedure. In the peripheral role, this sends the corresponding
valeyev 0:e056ac8fecf8 1109 * L2CAP request and waits for the central to perform the procedure.
valeyev 0:e056ac8fecf8 1110 *
valeyev 0:e056ac8fecf8 1111 * @param[in] handle Connection Handle.
valeyev 0:e056ac8fecf8 1112 * @param[in] params Pointer to desired connection parameters.
valeyev 0:e056ac8fecf8 1113 *
valeyev 0:e056ac8fecf8 1114 * @return BLE_ERROR_NONE if the connection parameters were updated correctly.
valeyev 0:e056ac8fecf8 1115 */
valeyev 0:e056ac8fecf8 1116 virtual ble_error_t updateConnectionParams(
valeyev 0:e056ac8fecf8 1117 Handle_t handle,
valeyev 0:e056ac8fecf8 1118 const ConnectionParams_t *params
valeyev 0:e056ac8fecf8 1119 ) {
valeyev 0:e056ac8fecf8 1120 /* avoid compiler warnings about unused variables */
valeyev 0:e056ac8fecf8 1121 (void)handle;
valeyev 0:e056ac8fecf8 1122 (void)params;
valeyev 0:e056ac8fecf8 1123
valeyev 0:e056ac8fecf8 1124 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1125 is supported. */
valeyev 0:e056ac8fecf8 1126 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1127 }
valeyev 0:e056ac8fecf8 1128
valeyev 0:e056ac8fecf8 1129 /**
valeyev 0:e056ac8fecf8 1130 * Set the value of the device name characteristic in the Generic Access
valeyev 0:e056ac8fecf8 1131 * Service.
valeyev 0:e056ac8fecf8 1132 *
valeyev 0:e056ac8fecf8 1133 * @param[in] deviceName The new value for the device-name. This is a
valeyev 0:e056ac8fecf8 1134 * UTF-8 encoded, <b>NULL-terminated</b> string.
valeyev 0:e056ac8fecf8 1135 *
valeyev 0:e056ac8fecf8 1136 * @return BLE_ERROR_NONE if the device name was set correctly.
valeyev 0:e056ac8fecf8 1137 */
valeyev 0:e056ac8fecf8 1138 virtual ble_error_t setDeviceName(const uint8_t *deviceName) {
valeyev 0:e056ac8fecf8 1139 /* Avoid compiler warnings about unused variables. */
valeyev 0:e056ac8fecf8 1140 (void)deviceName;
valeyev 0:e056ac8fecf8 1141
valeyev 0:e056ac8fecf8 1142 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1143 is supported. */
valeyev 0:e056ac8fecf8 1144 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1145 }
valeyev 0:e056ac8fecf8 1146
valeyev 0:e056ac8fecf8 1147 /**
valeyev 0:e056ac8fecf8 1148 * Get the value of the device name characteristic in the Generic Access
valeyev 0:e056ac8fecf8 1149 * Service.
valeyev 0:e056ac8fecf8 1150 *
valeyev 0:e056ac8fecf8 1151 * To obtain the length of the deviceName value, this function is
valeyev 0:e056ac8fecf8 1152 * invoked with the @p deviceName parameter set to NULL.
valeyev 0:e056ac8fecf8 1153 *
valeyev 0:e056ac8fecf8 1154 * @param[out] deviceName Pointer to an empty buffer where the UTF-8
valeyev 0:e056ac8fecf8 1155 * <b>non NULL-terminated</b> string is placed.
valeyev 0:e056ac8fecf8 1156 *
valeyev 0:e056ac8fecf8 1157 * @param[in,out] lengthP Length of the @p deviceName buffer. If the device
valeyev 0:e056ac8fecf8 1158 * name is successfully copied, then the length of the device name
valeyev 0:e056ac8fecf8 1159 * string (excluding the null terminator) replaces this value.
valeyev 0:e056ac8fecf8 1160 *
valeyev 0:e056ac8fecf8 1161 * @return BLE_ERROR_NONE if the device name was fetched correctly from the
valeyev 0:e056ac8fecf8 1162 * underlying BLE stack.
valeyev 0:e056ac8fecf8 1163 *
valeyev 0:e056ac8fecf8 1164 * @note If the device name is longer than the size of the supplied buffer,
valeyev 0:e056ac8fecf8 1165 * length returns the complete device name length and not the number of
valeyev 0:e056ac8fecf8 1166 * bytes actually returned in deviceName. The application may use this
valeyev 0:e056ac8fecf8 1167 * information to retry with a suitable buffer size.
valeyev 0:e056ac8fecf8 1168 */
valeyev 0:e056ac8fecf8 1169 virtual ble_error_t getDeviceName(uint8_t *deviceName, unsigned *lengthP)
valeyev 0:e056ac8fecf8 1170 {
valeyev 0:e056ac8fecf8 1171 /* avoid compiler warnings about unused variables */
valeyev 0:e056ac8fecf8 1172 (void)deviceName;
valeyev 0:e056ac8fecf8 1173 (void)lengthP;
valeyev 0:e056ac8fecf8 1174
valeyev 0:e056ac8fecf8 1175 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1176 is supported. */
valeyev 0:e056ac8fecf8 1177 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1178 }
valeyev 0:e056ac8fecf8 1179
valeyev 0:e056ac8fecf8 1180 /**
valeyev 0:e056ac8fecf8 1181 * Set the value of the appearance characteristic in the GAP service.
valeyev 0:e056ac8fecf8 1182 *
valeyev 0:e056ac8fecf8 1183 * @param[in] appearance The new value for the device-appearance.
valeyev 0:e056ac8fecf8 1184 *
valeyev 0:e056ac8fecf8 1185 * @return BLE_ERROR_NONE if the new appearance was set correctly.
valeyev 0:e056ac8fecf8 1186 */
valeyev 0:e056ac8fecf8 1187 virtual ble_error_t setAppearance(GapAdvertisingData::Appearance appearance)
valeyev 0:e056ac8fecf8 1188 {
valeyev 0:e056ac8fecf8 1189 /* Avoid compiler warnings about unused variables. */
valeyev 0:e056ac8fecf8 1190 (void)appearance;
valeyev 0:e056ac8fecf8 1191
valeyev 0:e056ac8fecf8 1192 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1193 is supported. */
valeyev 0:e056ac8fecf8 1194 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1195 }
valeyev 0:e056ac8fecf8 1196
valeyev 0:e056ac8fecf8 1197 /**
valeyev 0:e056ac8fecf8 1198 * Get the value of the appearance characteristic in the GAP service.
valeyev 0:e056ac8fecf8 1199 *
valeyev 0:e056ac8fecf8 1200 * @param[out] appearanceP The current device-appearance value.
valeyev 0:e056ac8fecf8 1201 *
valeyev 0:e056ac8fecf8 1202 * @return BLE_ERROR_NONE if the device-appearance was fetched correctly
valeyev 0:e056ac8fecf8 1203 * from the underlying BLE stack.
valeyev 0:e056ac8fecf8 1204 */
valeyev 0:e056ac8fecf8 1205 virtual ble_error_t getAppearance(GapAdvertisingData::Appearance *appearanceP)
valeyev 0:e056ac8fecf8 1206 {
valeyev 0:e056ac8fecf8 1207 /* Avoid compiler warnings about unused variables. */
valeyev 0:e056ac8fecf8 1208 (void)appearanceP;
valeyev 0:e056ac8fecf8 1209
valeyev 0:e056ac8fecf8 1210 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1211 is supported. */
valeyev 0:e056ac8fecf8 1212 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1213 }
valeyev 0:e056ac8fecf8 1214
valeyev 0:e056ac8fecf8 1215 /**
valeyev 0:e056ac8fecf8 1216 * Set the radio's transmit power.
valeyev 0:e056ac8fecf8 1217 *
valeyev 0:e056ac8fecf8 1218 * @param[in] txPower Radio's transmit power in dBm.
valeyev 0:e056ac8fecf8 1219 *
valeyev 0:e056ac8fecf8 1220 * @return BLE_ERROR_NONE if the new radio's transmit power was set
valeyev 0:e056ac8fecf8 1221 * correctly.
valeyev 0:e056ac8fecf8 1222 */
valeyev 0:e056ac8fecf8 1223 virtual ble_error_t setTxPower(int8_t txPower)
valeyev 0:e056ac8fecf8 1224 {
valeyev 0:e056ac8fecf8 1225 /* Avoid compiler warnings about unused variables. */
valeyev 0:e056ac8fecf8 1226 (void)txPower;
valeyev 0:e056ac8fecf8 1227
valeyev 0:e056ac8fecf8 1228 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1229 is supported. */
valeyev 0:e056ac8fecf8 1230 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1231 }
valeyev 0:e056ac8fecf8 1232
valeyev 0:e056ac8fecf8 1233 /**
valeyev 0:e056ac8fecf8 1234 * Query the underlying stack for allowed Tx power values.
valeyev 0:e056ac8fecf8 1235 *
valeyev 0:e056ac8fecf8 1236 * @param[out] valueArrayPP Receive the immutable array of Tx values.
valeyev 0:e056ac8fecf8 1237 * @param[out] countP Receive the array's size.
valeyev 0:e056ac8fecf8 1238 */
valeyev 0:e056ac8fecf8 1239 virtual void getPermittedTxPowerValues(
valeyev 0:e056ac8fecf8 1240 const int8_t **valueArrayPP, size_t *countP
valeyev 0:e056ac8fecf8 1241 ) {
valeyev 0:e056ac8fecf8 1242 /* Avoid compiler warnings about unused variables. */
valeyev 0:e056ac8fecf8 1243 (void)valueArrayPP;
valeyev 0:e056ac8fecf8 1244 (void)countP;
valeyev 0:e056ac8fecf8 1245
valeyev 0:e056ac8fecf8 1246 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1247 is supported. */
valeyev 0:e056ac8fecf8 1248 *countP = 0;
valeyev 0:e056ac8fecf8 1249 }
valeyev 0:e056ac8fecf8 1250
valeyev 0:e056ac8fecf8 1251 /**
valeyev 0:e056ac8fecf8 1252 * Get the maximum size of the whitelist.
valeyev 0:e056ac8fecf8 1253 *
valeyev 0:e056ac8fecf8 1254 * @return Maximum size of the whitelist.
valeyev 0:e056ac8fecf8 1255 *
valeyev 0:e056ac8fecf8 1256 * @note If using Mbed OS, you can configure the size of the whitelist by
valeyev 0:e056ac8fecf8 1257 * setting the YOTTA_CFG_WHITELIST_MAX_SIZE macro in your yotta config file.
valeyev 0:e056ac8fecf8 1258 */
valeyev 0:e056ac8fecf8 1259 virtual uint8_t getMaxWhitelistSize(void) const
valeyev 0:e056ac8fecf8 1260 {
valeyev 0:e056ac8fecf8 1261 return 0;
valeyev 0:e056ac8fecf8 1262 }
valeyev 0:e056ac8fecf8 1263
valeyev 0:e056ac8fecf8 1264 /**
valeyev 0:e056ac8fecf8 1265 * Get the Link Layer to use the internal whitelist when scanning,
valeyev 0:e056ac8fecf8 1266 * advertising or initiating a connection depending on the filter policies.
valeyev 0:e056ac8fecf8 1267 *
valeyev 0:e056ac8fecf8 1268 * @param[in,out] whitelist Define the whitelist instance which is used
valeyev 0:e056ac8fecf8 1269 * to store the whitelist requested. In input, the caller provisions memory.
valeyev 0:e056ac8fecf8 1270 *
valeyev 0:e056ac8fecf8 1271 * @return BLE_ERROR_NONE if the implementation's whitelist was successfully
valeyev 0:e056ac8fecf8 1272 * copied into the supplied reference.
valeyev 0:e056ac8fecf8 1273 */
valeyev 0:e056ac8fecf8 1274 virtual ble_error_t getWhitelist(Whitelist_t &whitelist) const
valeyev 0:e056ac8fecf8 1275 {
valeyev 0:e056ac8fecf8 1276 (void) whitelist;
valeyev 0:e056ac8fecf8 1277 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1278 }
valeyev 0:e056ac8fecf8 1279
valeyev 0:e056ac8fecf8 1280 /**
valeyev 0:e056ac8fecf8 1281 * Set the value of the whitelist to be used during GAP procedures.
valeyev 0:e056ac8fecf8 1282 *
valeyev 0:e056ac8fecf8 1283 * @param[in] whitelist A reference to a whitelist containing the addresses
valeyev 0:e056ac8fecf8 1284 * to be copied to the internal whitelist.
valeyev 0:e056ac8fecf8 1285 *
valeyev 0:e056ac8fecf8 1286 * @return BLE_ERROR_NONE if the implementation's whitelist was successfully
valeyev 0:e056ac8fecf8 1287 * populated with the addresses in the given whitelist.
valeyev 0:e056ac8fecf8 1288 *
valeyev 0:e056ac8fecf8 1289 * @note The whitelist must not contain addresses of type @ref
valeyev 0:e056ac8fecf8 1290 * BLEProtocol::AddressType::RANDOM_PRIVATE_NON_RESOLVABLE. This
valeyev 0:e056ac8fecf8 1291 * results in a @ref BLE_ERROR_INVALID_PARAM because the remote peer might
valeyev 0:e056ac8fecf8 1292 * change its private address at any time, and it is not possible to resolve
valeyev 0:e056ac8fecf8 1293 * it.
valeyev 0:e056ac8fecf8 1294 *
valeyev 0:e056ac8fecf8 1295 * @note If the input whitelist is larger than @ref getMaxWhitelistSize(),
valeyev 0:e056ac8fecf8 1296 * then @ref BLE_ERROR_PARAM_OUT_OF_RANGE is returned.
valeyev 0:e056ac8fecf8 1297 */
valeyev 0:e056ac8fecf8 1298 virtual ble_error_t setWhitelist(const Whitelist_t &whitelist)
valeyev 0:e056ac8fecf8 1299 {
valeyev 0:e056ac8fecf8 1300 (void) whitelist;
valeyev 0:e056ac8fecf8 1301 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1302 }
valeyev 0:e056ac8fecf8 1303
valeyev 0:e056ac8fecf8 1304 /**
valeyev 0:e056ac8fecf8 1305 * Set the advertising policy filter mode to be used during the next
valeyev 0:e056ac8fecf8 1306 * advertising procedure.
valeyev 0:e056ac8fecf8 1307 *
valeyev 0:e056ac8fecf8 1308 * @param[in] mode New advertising policy filter mode.
valeyev 0:e056ac8fecf8 1309 *
valeyev 0:e056ac8fecf8 1310 * @return BLE_ERROR_NONE if the specified policy filter mode was set
valeyev 0:e056ac8fecf8 1311 * successfully.
valeyev 0:e056ac8fecf8 1312 */
valeyev 0:e056ac8fecf8 1313 virtual ble_error_t setAdvertisingPolicyMode(AdvertisingPolicyMode_t mode)
valeyev 0:e056ac8fecf8 1314 {
valeyev 0:e056ac8fecf8 1315 (void) mode;
valeyev 0:e056ac8fecf8 1316 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1317 }
valeyev 0:e056ac8fecf8 1318
valeyev 0:e056ac8fecf8 1319 /**
valeyev 0:e056ac8fecf8 1320 * Set the scan policy filter mode to be used during the next scan procedure.
valeyev 0:e056ac8fecf8 1321 *
valeyev 0:e056ac8fecf8 1322 * @param[in] mode New scan policy filter mode.
valeyev 0:e056ac8fecf8 1323 *
valeyev 0:e056ac8fecf8 1324 * @return BLE_ERROR_NONE if the specified policy filter mode was set
valeyev 0:e056ac8fecf8 1325 * successfully.
valeyev 0:e056ac8fecf8 1326 */
valeyev 0:e056ac8fecf8 1327 virtual ble_error_t setScanningPolicyMode(ScanningPolicyMode_t mode)
valeyev 0:e056ac8fecf8 1328 {
valeyev 0:e056ac8fecf8 1329 (void) mode;
valeyev 0:e056ac8fecf8 1330 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1331 }
valeyev 0:e056ac8fecf8 1332
valeyev 0:e056ac8fecf8 1333 /**
valeyev 0:e056ac8fecf8 1334 * Set the initiator policy filter mode to be used during the next connection
valeyev 0:e056ac8fecf8 1335 * initiation.
valeyev 0:e056ac8fecf8 1336 *
valeyev 0:e056ac8fecf8 1337 * @param[in] mode New initiator policy filter mode.
valeyev 0:e056ac8fecf8 1338 *
valeyev 0:e056ac8fecf8 1339 * @return BLE_ERROR_NONE if the specified policy filter mode was set
valeyev 0:e056ac8fecf8 1340 * successfully.
valeyev 0:e056ac8fecf8 1341 */
valeyev 0:e056ac8fecf8 1342 virtual ble_error_t setInitiatorPolicyMode(InitiatorPolicyMode_t mode)
valeyev 0:e056ac8fecf8 1343 {
valeyev 0:e056ac8fecf8 1344 (void) mode;
valeyev 0:e056ac8fecf8 1345 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1346 }
valeyev 0:e056ac8fecf8 1347
valeyev 0:e056ac8fecf8 1348 /**
valeyev 0:e056ac8fecf8 1349 * Get the current advertising policy filter mode.
valeyev 0:e056ac8fecf8 1350 *
valeyev 0:e056ac8fecf8 1351 * @return The current advertising policy filter mode.
valeyev 0:e056ac8fecf8 1352 */
valeyev 0:e056ac8fecf8 1353 virtual AdvertisingPolicyMode_t getAdvertisingPolicyMode(void) const
valeyev 0:e056ac8fecf8 1354 {
valeyev 0:e056ac8fecf8 1355 return ADV_POLICY_IGNORE_WHITELIST;
valeyev 0:e056ac8fecf8 1356 }
valeyev 0:e056ac8fecf8 1357
valeyev 0:e056ac8fecf8 1358 /**
valeyev 0:e056ac8fecf8 1359 * Get the current scan policy filter mode.
valeyev 0:e056ac8fecf8 1360 *
valeyev 0:e056ac8fecf8 1361 * @return The current scan policy filter mode.
valeyev 0:e056ac8fecf8 1362 */
valeyev 0:e056ac8fecf8 1363 virtual ScanningPolicyMode_t getScanningPolicyMode(void) const
valeyev 0:e056ac8fecf8 1364 {
valeyev 0:e056ac8fecf8 1365 return SCAN_POLICY_IGNORE_WHITELIST;
valeyev 0:e056ac8fecf8 1366 }
valeyev 0:e056ac8fecf8 1367
valeyev 0:e056ac8fecf8 1368 /**
valeyev 0:e056ac8fecf8 1369 * Get the current initiator policy filter mode.
valeyev 0:e056ac8fecf8 1370 *
valeyev 0:e056ac8fecf8 1371 * @return The current scan policy filter mode.
valeyev 0:e056ac8fecf8 1372 */
valeyev 0:e056ac8fecf8 1373 virtual InitiatorPolicyMode_t getInitiatorPolicyMode(void) const
valeyev 0:e056ac8fecf8 1374 {
valeyev 0:e056ac8fecf8 1375 return INIT_POLICY_IGNORE_WHITELIST;
valeyev 0:e056ac8fecf8 1376 }
valeyev 0:e056ac8fecf8 1377
valeyev 0:e056ac8fecf8 1378 protected:
valeyev 0:e056ac8fecf8 1379 /* Override the following in the underlying adaptation layer to provide the
valeyev 0:e056ac8fecf8 1380 functionality of scanning. */
valeyev 0:e056ac8fecf8 1381
valeyev 0:e056ac8fecf8 1382 /**
valeyev 0:e056ac8fecf8 1383 * Start scanning procedure in the underlying BLE stack.
valeyev 0:e056ac8fecf8 1384 *
valeyev 0:e056ac8fecf8 1385 * @param[in] scanningParams Parameters of the scan procedure.
valeyev 0:e056ac8fecf8 1386 *
valeyev 0:e056ac8fecf8 1387 * @return BLE_ERROR_NONE if the scan procedure was successfully started.
valeyev 0:e056ac8fecf8 1388 */
valeyev 0:e056ac8fecf8 1389 virtual ble_error_t startRadioScan(const GapScanningParams &scanningParams)
valeyev 0:e056ac8fecf8 1390 {
valeyev 0:e056ac8fecf8 1391 (void)scanningParams;
valeyev 0:e056ac8fecf8 1392 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1393 is supported. */
valeyev 0:e056ac8fecf8 1394 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1395 }
valeyev 0:e056ac8fecf8 1396
valeyev 0:e056ac8fecf8 1397 /*
valeyev 0:e056ac8fecf8 1398 * APIs with nonvirtual implementations.
valeyev 0:e056ac8fecf8 1399 */
valeyev 0:e056ac8fecf8 1400 public:
valeyev 0:e056ac8fecf8 1401 /**
valeyev 0:e056ac8fecf8 1402 * Get the current advertising and connection states of the device.
valeyev 0:e056ac8fecf8 1403 *
valeyev 0:e056ac8fecf8 1404 * @return The current GAP state of the device.
valeyev 0:e056ac8fecf8 1405 */
valeyev 0:e056ac8fecf8 1406 GapState_t getState(void) const
valeyev 0:e056ac8fecf8 1407 {
valeyev 0:e056ac8fecf8 1408 return state;
valeyev 0:e056ac8fecf8 1409 }
valeyev 0:e056ac8fecf8 1410
valeyev 0:e056ac8fecf8 1411 /**
valeyev 0:e056ac8fecf8 1412 * Set the advertising type to use during the advertising procedure.
valeyev 0:e056ac8fecf8 1413 *
valeyev 0:e056ac8fecf8 1414 * @param[in] advType New type of advertising to use.
valeyev 0:e056ac8fecf8 1415 */
valeyev 0:e056ac8fecf8 1416 void setAdvertisingType(GapAdvertisingParams::AdvertisingType_t advType)
valeyev 0:e056ac8fecf8 1417 {
valeyev 0:e056ac8fecf8 1418 _advParams.setAdvertisingType(advType);
valeyev 0:e056ac8fecf8 1419 }
valeyev 0:e056ac8fecf8 1420
valeyev 0:e056ac8fecf8 1421 /**
valeyev 0:e056ac8fecf8 1422 * Set the advertising interval.
valeyev 0:e056ac8fecf8 1423 *
valeyev 0:e056ac8fecf8 1424 * @param[in] interval Advertising interval in units of milliseconds.
valeyev 0:e056ac8fecf8 1425 * Advertising is disabled if interval is 0. If interval is smaller than
valeyev 0:e056ac8fecf8 1426 * the minimum supported value, then the minimum supported value is used
valeyev 0:e056ac8fecf8 1427 * instead. This minimum value can be discovered using
valeyev 0:e056ac8fecf8 1428 * getMinAdvertisingInterval().
valeyev 0:e056ac8fecf8 1429 *
valeyev 0:e056ac8fecf8 1430 * This field must be set to 0 if connectionMode is equal
valeyev 0:e056ac8fecf8 1431 * to ADV_CONNECTABLE_DIRECTED.
valeyev 0:e056ac8fecf8 1432 *
valeyev 0:e056ac8fecf8 1433 * @note Decreasing this value allows central devices to detect a
valeyev 0:e056ac8fecf8 1434 * peripheral faster, at the expense of the radio using more power
valeyev 0:e056ac8fecf8 1435 * due to the higher data transmit rate.
valeyev 0:e056ac8fecf8 1436 */
valeyev 0:e056ac8fecf8 1437 void setAdvertisingInterval(uint16_t interval)
valeyev 0:e056ac8fecf8 1438 {
valeyev 0:e056ac8fecf8 1439 if (interval == 0) {
valeyev 0:e056ac8fecf8 1440 stopAdvertising();
valeyev 0:e056ac8fecf8 1441 } else if (interval < getMinAdvertisingInterval()) {
valeyev 0:e056ac8fecf8 1442 interval = getMinAdvertisingInterval();
valeyev 0:e056ac8fecf8 1443 }
valeyev 0:e056ac8fecf8 1444 _advParams.setInterval(interval);
valeyev 0:e056ac8fecf8 1445 }
valeyev 0:e056ac8fecf8 1446
valeyev 0:e056ac8fecf8 1447 /**
valeyev 0:e056ac8fecf8 1448 * Set the advertising duration.
valeyev 0:e056ac8fecf8 1449 *
valeyev 0:e056ac8fecf8 1450 * A timeout event is genenerated once the advertising period expired.
valeyev 0:e056ac8fecf8 1451 *
valeyev 0:e056ac8fecf8 1452 * @param[in] timeout Advertising timeout (in seconds) between 0x1 and 0x3FFF.
valeyev 0:e056ac8fecf8 1453 * The special value 0 may be used to disable the advertising timeout.
valeyev 0:e056ac8fecf8 1454 */
valeyev 0:e056ac8fecf8 1455 void setAdvertisingTimeout(uint16_t timeout)
valeyev 0:e056ac8fecf8 1456 {
valeyev 0:e056ac8fecf8 1457 _advParams.setTimeout(timeout);
valeyev 0:e056ac8fecf8 1458 }
valeyev 0:e056ac8fecf8 1459
valeyev 0:e056ac8fecf8 1460 /**
valeyev 0:e056ac8fecf8 1461 * Start the advertising procedure.
valeyev 0:e056ac8fecf8 1462 *
valeyev 0:e056ac8fecf8 1463 * @return BLE_ERROR_NONE if the device started advertising successfully.
valeyev 0:e056ac8fecf8 1464 */
valeyev 0:e056ac8fecf8 1465 ble_error_t startAdvertising(void)
valeyev 0:e056ac8fecf8 1466 {
valeyev 0:e056ac8fecf8 1467 ble_error_t rc;
valeyev 0:e056ac8fecf8 1468 if ((rc = startAdvertising(_advParams)) == BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1469 state.advertising = 1;
valeyev 0:e056ac8fecf8 1470 }
valeyev 0:e056ac8fecf8 1471 return rc;
valeyev 0:e056ac8fecf8 1472 }
valeyev 0:e056ac8fecf8 1473
valeyev 0:e056ac8fecf8 1474 /**
valeyev 0:e056ac8fecf8 1475 * Reset the value of the advertising payload advertised.
valeyev 0:e056ac8fecf8 1476 */
valeyev 0:e056ac8fecf8 1477 void clearAdvertisingPayload(void)
valeyev 0:e056ac8fecf8 1478 {
valeyev 0:e056ac8fecf8 1479 _advPayload.clear();
valeyev 0:e056ac8fecf8 1480 setAdvertisingData(_advPayload, _scanResponse);
valeyev 0:e056ac8fecf8 1481 }
valeyev 0:e056ac8fecf8 1482
valeyev 0:e056ac8fecf8 1483 /**
valeyev 0:e056ac8fecf8 1484 * Set gap flags in the advertising payload.
valeyev 0:e056ac8fecf8 1485 *
valeyev 0:e056ac8fecf8 1486 * A call to this function is equivalent to:
valeyev 0:e056ac8fecf8 1487 *
valeyev 0:e056ac8fecf8 1488 * @code
valeyev 0:e056ac8fecf8 1489 * Gap &gap;
valeyev 0:e056ac8fecf8 1490 *
valeyev 0:e056ac8fecf8 1491 * GapAdvertisingData payload = gap.getAdvertisingPayload();
valeyev 0:e056ac8fecf8 1492 * payload.addFlags(flags);
valeyev 0:e056ac8fecf8 1493 * gap.setAdvertisingPayload(payload);
valeyev 0:e056ac8fecf8 1494 * @endcode
valeyev 0:e056ac8fecf8 1495 *
valeyev 0:e056ac8fecf8 1496 * @param[in] flags The flags to be added.
valeyev 0:e056ac8fecf8 1497 *
valeyev 0:e056ac8fecf8 1498 * @return BLE_ERROR_NONE if the data was successfully added to the
valeyev 0:e056ac8fecf8 1499 * advertising payload.
valeyev 0:e056ac8fecf8 1500 */
valeyev 0:e056ac8fecf8 1501 ble_error_t accumulateAdvertisingPayload(uint8_t flags)
valeyev 0:e056ac8fecf8 1502 {
valeyev 0:e056ac8fecf8 1503 GapAdvertisingData advPayloadCopy = _advPayload;
valeyev 0:e056ac8fecf8 1504 ble_error_t rc;
valeyev 0:e056ac8fecf8 1505 if ((rc = advPayloadCopy.addFlags(flags)) != BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1506 return rc;
valeyev 0:e056ac8fecf8 1507 }
valeyev 0:e056ac8fecf8 1508
valeyev 0:e056ac8fecf8 1509 rc = setAdvertisingData(advPayloadCopy, _scanResponse);
valeyev 0:e056ac8fecf8 1510 if (rc == BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1511 _advPayload = advPayloadCopy;
valeyev 0:e056ac8fecf8 1512 }
valeyev 0:e056ac8fecf8 1513
valeyev 0:e056ac8fecf8 1514 return rc;
valeyev 0:e056ac8fecf8 1515 }
valeyev 0:e056ac8fecf8 1516
valeyev 0:e056ac8fecf8 1517 /**
valeyev 0:e056ac8fecf8 1518 * Set the appearance field in the advertising payload.
valeyev 0:e056ac8fecf8 1519 *
valeyev 0:e056ac8fecf8 1520 * A call to this function is equivalent to:
valeyev 0:e056ac8fecf8 1521 *
valeyev 0:e056ac8fecf8 1522 * @code
valeyev 0:e056ac8fecf8 1523 * Gap &gap;
valeyev 0:e056ac8fecf8 1524 *
valeyev 0:e056ac8fecf8 1525 * GapAdvertisingData payload = gap.getAdvertisingPayload();
valeyev 0:e056ac8fecf8 1526 * payload.addAppearance(app);
valeyev 0:e056ac8fecf8 1527 * gap.setAdvertisingPayload(payload);
valeyev 0:e056ac8fecf8 1528 * @endcode
valeyev 0:e056ac8fecf8 1529 *
valeyev 0:e056ac8fecf8 1530 * @param[in] app The appearance to advertise.
valeyev 0:e056ac8fecf8 1531 *
valeyev 0:e056ac8fecf8 1532 * @return BLE_ERROR_NONE if the data was successfully added to the
valeyev 0:e056ac8fecf8 1533 * advertising payload.
valeyev 0:e056ac8fecf8 1534 */
valeyev 0:e056ac8fecf8 1535 ble_error_t accumulateAdvertisingPayload(GapAdvertisingData::Appearance app)
valeyev 0:e056ac8fecf8 1536 {
valeyev 0:e056ac8fecf8 1537 GapAdvertisingData advPayloadCopy = _advPayload;
valeyev 0:e056ac8fecf8 1538 ble_error_t rc;
valeyev 0:e056ac8fecf8 1539 if ((rc = advPayloadCopy.addAppearance(app)) != BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1540 return rc;
valeyev 0:e056ac8fecf8 1541 }
valeyev 0:e056ac8fecf8 1542
valeyev 0:e056ac8fecf8 1543 rc = setAdvertisingData(advPayloadCopy, _scanResponse);
valeyev 0:e056ac8fecf8 1544 if (rc == BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1545 _advPayload = advPayloadCopy;
valeyev 0:e056ac8fecf8 1546 }
valeyev 0:e056ac8fecf8 1547
valeyev 0:e056ac8fecf8 1548 return rc;
valeyev 0:e056ac8fecf8 1549 }
valeyev 0:e056ac8fecf8 1550
valeyev 0:e056ac8fecf8 1551 /**
valeyev 0:e056ac8fecf8 1552 * Set the Tx Power field in the advertising payload.
valeyev 0:e056ac8fecf8 1553 *
valeyev 0:e056ac8fecf8 1554 * A call to this function is equivalent to:
valeyev 0:e056ac8fecf8 1555 *
valeyev 0:e056ac8fecf8 1556 * @code
valeyev 0:e056ac8fecf8 1557 * Gap &gap;
valeyev 0:e056ac8fecf8 1558 *
valeyev 0:e056ac8fecf8 1559 * GapAdvertisingData payload = gap.getAdvertisingPayload();
valeyev 0:e056ac8fecf8 1560 * payload.addTxPower(power);
valeyev 0:e056ac8fecf8 1561 * gap.setAdvertisingPayload(payload);
valeyev 0:e056ac8fecf8 1562 * @endcode
valeyev 0:e056ac8fecf8 1563 *
valeyev 0:e056ac8fecf8 1564 * @param[in] power Transmit power in dBm used by the controller to advertise.
valeyev 0:e056ac8fecf8 1565 *
valeyev 0:e056ac8fecf8 1566 * @return BLE_ERROR_NONE if the data was successfully added to the
valeyev 0:e056ac8fecf8 1567 * advertising payload.
valeyev 0:e056ac8fecf8 1568 */
valeyev 0:e056ac8fecf8 1569 ble_error_t accumulateAdvertisingPayloadTxPower(int8_t power)
valeyev 0:e056ac8fecf8 1570 {
valeyev 0:e056ac8fecf8 1571 GapAdvertisingData advPayloadCopy = _advPayload;
valeyev 0:e056ac8fecf8 1572 ble_error_t rc;
valeyev 0:e056ac8fecf8 1573 if ((rc = advPayloadCopy.addTxPower(power)) != BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1574 return rc;
valeyev 0:e056ac8fecf8 1575 }
valeyev 0:e056ac8fecf8 1576
valeyev 0:e056ac8fecf8 1577 rc = setAdvertisingData(advPayloadCopy, _scanResponse);
valeyev 0:e056ac8fecf8 1578 if (rc == BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1579 _advPayload = advPayloadCopy;
valeyev 0:e056ac8fecf8 1580 }
valeyev 0:e056ac8fecf8 1581
valeyev 0:e056ac8fecf8 1582 return rc;
valeyev 0:e056ac8fecf8 1583 }
valeyev 0:e056ac8fecf8 1584
valeyev 0:e056ac8fecf8 1585 /**
valeyev 0:e056ac8fecf8 1586 * Add a new field in the advertising payload.
valeyev 0:e056ac8fecf8 1587 *
valeyev 0:e056ac8fecf8 1588 * A call to this function is equivalent to:
valeyev 0:e056ac8fecf8 1589 *
valeyev 0:e056ac8fecf8 1590 * @code
valeyev 0:e056ac8fecf8 1591 * Gap &gap;
valeyev 0:e056ac8fecf8 1592 *
valeyev 0:e056ac8fecf8 1593 * GapAdvertisingData payload = gap.getAdvertisingPayload();
valeyev 0:e056ac8fecf8 1594 * payload.addData(type, data, len);
valeyev 0:e056ac8fecf8 1595 * gap.setAdvertisingPayload(payload);
valeyev 0:e056ac8fecf8 1596 * @endcode
valeyev 0:e056ac8fecf8 1597 *
valeyev 0:e056ac8fecf8 1598 * @param[in] type Identity of the field being added.
valeyev 0:e056ac8fecf8 1599 * @param[in] data Buffer containing the value of the field.
valeyev 0:e056ac8fecf8 1600 * @param[in] len Length of the data buffer.
valeyev 0:e056ac8fecf8 1601 *
valeyev 0:e056ac8fecf8 1602 * @return BLE_ERROR_NONE if the advertisement payload was updated based on
valeyev 0:e056ac8fecf8 1603 * matching AD type; otherwise, an appropriate error.
valeyev 0:e056ac8fecf8 1604 *
valeyev 0:e056ac8fecf8 1605 * @note When the specified AD type is INCOMPLETE_LIST_16BIT_SERVICE_IDS,
valeyev 0:e056ac8fecf8 1606 * COMPLETE_LIST_16BIT_SERVICE_IDS, INCOMPLETE_LIST_32BIT_SERVICE_IDS,
valeyev 0:e056ac8fecf8 1607 * COMPLETE_LIST_32BIT_SERVICE_IDS, INCOMPLETE_LIST_128BIT_SERVICE_IDS,
valeyev 0:e056ac8fecf8 1608 * COMPLETE_LIST_128BIT_SERVICE_IDS or LIST_128BIT_SOLICITATION_IDS the
valeyev 0:e056ac8fecf8 1609 * supplied value is appended to the values previously added to the payload.
valeyev 0:e056ac8fecf8 1610 */
valeyev 0:e056ac8fecf8 1611 ble_error_t accumulateAdvertisingPayload(
valeyev 0:e056ac8fecf8 1612 GapAdvertisingData::DataType type, const uint8_t *data, uint8_t len
valeyev 0:e056ac8fecf8 1613 ) {
valeyev 0:e056ac8fecf8 1614 GapAdvertisingData advPayloadCopy = _advPayload;
valeyev 0:e056ac8fecf8 1615 ble_error_t rc;
valeyev 0:e056ac8fecf8 1616 if ((rc = advPayloadCopy.addData(type, data, len)) != BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1617 return rc;
valeyev 0:e056ac8fecf8 1618 }
valeyev 0:e056ac8fecf8 1619
valeyev 0:e056ac8fecf8 1620 rc = setAdvertisingData(advPayloadCopy, _scanResponse);
valeyev 0:e056ac8fecf8 1621 if (rc == BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1622 _advPayload = advPayloadCopy;
valeyev 0:e056ac8fecf8 1623 }
valeyev 0:e056ac8fecf8 1624
valeyev 0:e056ac8fecf8 1625 return rc;
valeyev 0:e056ac8fecf8 1626 }
valeyev 0:e056ac8fecf8 1627
valeyev 0:e056ac8fecf8 1628 /**
valeyev 0:e056ac8fecf8 1629 * Update a particular field in the advertising payload.
valeyev 0:e056ac8fecf8 1630 *
valeyev 0:e056ac8fecf8 1631 * A call to this function is equivalent to:
valeyev 0:e056ac8fecf8 1632 *
valeyev 0:e056ac8fecf8 1633 * @code
valeyev 0:e056ac8fecf8 1634 * Gap &gap;
valeyev 0:e056ac8fecf8 1635 *
valeyev 0:e056ac8fecf8 1636 * GapAdvertisingData payload = gap.getAdvertisingPayload();
valeyev 0:e056ac8fecf8 1637 * payload.updateData(type, data, len);
valeyev 0:e056ac8fecf8 1638 * gap.setAdvertisingPayload(payload);
valeyev 0:e056ac8fecf8 1639 * @endcode
valeyev 0:e056ac8fecf8 1640 *
valeyev 0:e056ac8fecf8 1641 *
valeyev 0:e056ac8fecf8 1642 * @param[in] type Id of the field to update.
valeyev 0:e056ac8fecf8 1643 * @param[in] data data buffer containing the new value of the field.
valeyev 0:e056ac8fecf8 1644 * @param[in] len Length of the data buffer.
valeyev 0:e056ac8fecf8 1645 *
valeyev 0:e056ac8fecf8 1646 * @note If advertisements are enabled, then the update takes effect
valeyev 0:e056ac8fecf8 1647 * immediately.
valeyev 0:e056ac8fecf8 1648 *
valeyev 0:e056ac8fecf8 1649 * @return BLE_ERROR_NONE if the advertisement payload was updated based on
valeyev 0:e056ac8fecf8 1650 * matching AD type; otherwise, an appropriate error.
valeyev 0:e056ac8fecf8 1651 */
valeyev 0:e056ac8fecf8 1652 ble_error_t updateAdvertisingPayload(
valeyev 0:e056ac8fecf8 1653 GapAdvertisingData::DataType type, const uint8_t *data, uint8_t len
valeyev 0:e056ac8fecf8 1654 ) {
valeyev 0:e056ac8fecf8 1655 GapAdvertisingData advPayloadCopy = _advPayload;
valeyev 0:e056ac8fecf8 1656 ble_error_t rc;
valeyev 0:e056ac8fecf8 1657 if ((rc = advPayloadCopy.updateData(type, data, len)) != BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1658 return rc;
valeyev 0:e056ac8fecf8 1659 }
valeyev 0:e056ac8fecf8 1660
valeyev 0:e056ac8fecf8 1661 rc = setAdvertisingData(advPayloadCopy, _scanResponse);
valeyev 0:e056ac8fecf8 1662 if (rc == BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1663 _advPayload = advPayloadCopy;
valeyev 0:e056ac8fecf8 1664 }
valeyev 0:e056ac8fecf8 1665
valeyev 0:e056ac8fecf8 1666 return rc;
valeyev 0:e056ac8fecf8 1667 }
valeyev 0:e056ac8fecf8 1668
valeyev 0:e056ac8fecf8 1669 /**
valeyev 0:e056ac8fecf8 1670 * Set the value of the payload advertised.
valeyev 0:e056ac8fecf8 1671 *
valeyev 0:e056ac8fecf8 1672 * @param[in] payload A reference to a user constructed advertisement
valeyev 0:e056ac8fecf8 1673 * payload to set.
valeyev 0:e056ac8fecf8 1674 *
valeyev 0:e056ac8fecf8 1675 * @return BLE_ERROR_NONE if the advertisement payload was successfully
valeyev 0:e056ac8fecf8 1676 * set.
valeyev 0:e056ac8fecf8 1677 */
valeyev 0:e056ac8fecf8 1678 ble_error_t setAdvertisingPayload(const GapAdvertisingData &payload)
valeyev 0:e056ac8fecf8 1679 {
valeyev 0:e056ac8fecf8 1680 ble_error_t rc = setAdvertisingData(payload, _scanResponse);
valeyev 0:e056ac8fecf8 1681 if (rc == BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1682 _advPayload = payload;
valeyev 0:e056ac8fecf8 1683 }
valeyev 0:e056ac8fecf8 1684
valeyev 0:e056ac8fecf8 1685 return rc;
valeyev 0:e056ac8fecf8 1686 }
valeyev 0:e056ac8fecf8 1687
valeyev 0:e056ac8fecf8 1688 /**
valeyev 0:e056ac8fecf8 1689 * Get a reference to the current advertising payload.
valeyev 0:e056ac8fecf8 1690 *
valeyev 0:e056ac8fecf8 1691 * @return A reference to the current advertising payload.
valeyev 0:e056ac8fecf8 1692 */
valeyev 0:e056ac8fecf8 1693 const GapAdvertisingData &getAdvertisingPayload(void) const
valeyev 0:e056ac8fecf8 1694 {
valeyev 0:e056ac8fecf8 1695 return _advPayload;
valeyev 0:e056ac8fecf8 1696 }
valeyev 0:e056ac8fecf8 1697
valeyev 0:e056ac8fecf8 1698 /**
valeyev 0:e056ac8fecf8 1699 * Add a new field in the advertising payload.
valeyev 0:e056ac8fecf8 1700 *
valeyev 0:e056ac8fecf8 1701 * @param[in] type AD type identifier.
valeyev 0:e056ac8fecf8 1702 * @param[in] data buffer containing AD data.
valeyev 0:e056ac8fecf8 1703 * @param[in] len Length of the data buffer.
valeyev 0:e056ac8fecf8 1704 *
valeyev 0:e056ac8fecf8 1705 * @return BLE_ERROR_NONE if the data was successfully added to the scan
valeyev 0:e056ac8fecf8 1706 * response payload.
valeyev 0:e056ac8fecf8 1707 */
valeyev 0:e056ac8fecf8 1708 ble_error_t accumulateScanResponse(
valeyev 0:e056ac8fecf8 1709 GapAdvertisingData::DataType type, const uint8_t *data, uint8_t len
valeyev 0:e056ac8fecf8 1710 ) {
valeyev 0:e056ac8fecf8 1711 GapAdvertisingData scanResponseCopy = _scanResponse;
valeyev 0:e056ac8fecf8 1712 ble_error_t rc;
valeyev 0:e056ac8fecf8 1713 if ((rc = scanResponseCopy.addData(type, data, len)) != BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1714 return rc;
valeyev 0:e056ac8fecf8 1715 }
valeyev 0:e056ac8fecf8 1716
valeyev 0:e056ac8fecf8 1717 rc = setAdvertisingData(_advPayload, scanResponseCopy);
valeyev 0:e056ac8fecf8 1718 if (rc == BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1719 _scanResponse = scanResponseCopy;
valeyev 0:e056ac8fecf8 1720 }
valeyev 0:e056ac8fecf8 1721
valeyev 0:e056ac8fecf8 1722 return rc;
valeyev 0:e056ac8fecf8 1723 }
valeyev 0:e056ac8fecf8 1724
valeyev 0:e056ac8fecf8 1725 /**
valeyev 0:e056ac8fecf8 1726 * Reset the content of the scan response.
valeyev 0:e056ac8fecf8 1727 *
valeyev 0:e056ac8fecf8 1728 * @note This should be followed by a call to Gap::setAdvertisingPayload()
valeyev 0:e056ac8fecf8 1729 * or Gap::startAdvertising() before the update takes effect.
valeyev 0:e056ac8fecf8 1730 */
valeyev 0:e056ac8fecf8 1731 void clearScanResponse(void) {
valeyev 0:e056ac8fecf8 1732 _scanResponse.clear();
valeyev 0:e056ac8fecf8 1733 setAdvertisingData(_advPayload, _scanResponse);
valeyev 0:e056ac8fecf8 1734 }
valeyev 0:e056ac8fecf8 1735
valeyev 0:e056ac8fecf8 1736 /**
valeyev 0:e056ac8fecf8 1737 * Set the parameters used during a scan procedure.
valeyev 0:e056ac8fecf8 1738 *
valeyev 0:e056ac8fecf8 1739 * @param[in] interval in ms between the start of two consecutive scan windows.
valeyev 0:e056ac8fecf8 1740 * That value is greater or equal to the scan window value. The
valeyev 0:e056ac8fecf8 1741 * maximum allowed value is 10.24ms.
valeyev 0:e056ac8fecf8 1742 *
valeyev 0:e056ac8fecf8 1743 * @param[in] window Period in ms during which the scanner listens to
valeyev 0:e056ac8fecf8 1744 * advertising channels. That value is in the range 2.5ms to 10.24s.
valeyev 0:e056ac8fecf8 1745 *
valeyev 0:e056ac8fecf8 1746 * @param[in] timeout Duration in seconds of the scan procedure if any. The
valeyev 0:e056ac8fecf8 1747 * special value 0 disable specific duration of the scan procedure.
valeyev 0:e056ac8fecf8 1748 *
valeyev 0:e056ac8fecf8 1749 * @param[in] activeScanning If set to true, then the scanner sends scan
valeyev 0:e056ac8fecf8 1750 * requests to a scannable or connectable advertiser. If set to false, then the
valeyev 0:e056ac8fecf8 1751 * scanner does not send any request during the scan procedure.
valeyev 0:e056ac8fecf8 1752 *
valeyev 0:e056ac8fecf8 1753 * @return BLE_ERROR_NONE if the scan parameters were correctly set.
valeyev 0:e056ac8fecf8 1754 *
valeyev 0:e056ac8fecf8 1755 * @note The scanning window divided by the interval determines the duty
valeyev 0:e056ac8fecf8 1756 * cycle for scanning. For example, if the interval is 100ms and the window
valeyev 0:e056ac8fecf8 1757 * is 10ms, then the controller scans for 10 percent of the time.
valeyev 0:e056ac8fecf8 1758 *
valeyev 0:e056ac8fecf8 1759 * @note If the interval and the window are set to the same value, then the
valeyev 0:e056ac8fecf8 1760 * device scans continuously during the scan procedure. The scanning
valeyev 0:e056ac8fecf8 1761 * frequency changes at every interval.
valeyev 0:e056ac8fecf8 1762 *
valeyev 0:e056ac8fecf8 1763 * @note Once the scanning parameters have been configured, scanning can be
valeyev 0:e056ac8fecf8 1764 * enabled by using startScan().
valeyev 0:e056ac8fecf8 1765 *
valeyev 0:e056ac8fecf8 1766 * @note The scan interval and window are recommendations to the BLE stack.
valeyev 0:e056ac8fecf8 1767 */
valeyev 0:e056ac8fecf8 1768 ble_error_t setScanParams(
valeyev 0:e056ac8fecf8 1769 uint16_t interval = GapScanningParams::SCAN_INTERVAL_MAX,
valeyev 0:e056ac8fecf8 1770 uint16_t window = GapScanningParams::SCAN_WINDOW_MAX,
valeyev 0:e056ac8fecf8 1771 uint16_t timeout = 0,
valeyev 0:e056ac8fecf8 1772 bool activeScanning = false
valeyev 0:e056ac8fecf8 1773 ) {
valeyev 0:e056ac8fecf8 1774 ble_error_t rc;
valeyev 0:e056ac8fecf8 1775 if (((rc = _scanningParams.setInterval(interval)) == BLE_ERROR_NONE) &&
valeyev 0:e056ac8fecf8 1776 ((rc = _scanningParams.setWindow(window)) == BLE_ERROR_NONE) &&
valeyev 0:e056ac8fecf8 1777 ((rc = _scanningParams.setTimeout(timeout)) == BLE_ERROR_NONE)) {
valeyev 0:e056ac8fecf8 1778 _scanningParams.setActiveScanning(activeScanning);
valeyev 0:e056ac8fecf8 1779 return BLE_ERROR_NONE;
valeyev 0:e056ac8fecf8 1780 }
valeyev 0:e056ac8fecf8 1781
valeyev 0:e056ac8fecf8 1782 return rc;
valeyev 0:e056ac8fecf8 1783 }
valeyev 0:e056ac8fecf8 1784
valeyev 0:e056ac8fecf8 1785 /**
valeyev 0:e056ac8fecf8 1786 * Set the interval parameter used during scanning procedures.
valeyev 0:e056ac8fecf8 1787 *
valeyev 0:e056ac8fecf8 1788 * @param[in] interval Interval in ms between the start of two consecutive
valeyev 0:e056ac8fecf8 1789 * scan windows. That value is greater or equal to the scan window value.
valeyev 0:e056ac8fecf8 1790 * The maximum allowed value is 10.24ms.
valeyev 0:e056ac8fecf8 1791 *
valeyev 0:e056ac8fecf8 1792 * @return BLE_ERROR_NONE if the scan interval was correctly set.
valeyev 0:e056ac8fecf8 1793 */
valeyev 0:e056ac8fecf8 1794 ble_error_t setScanInterval(uint16_t interval)
valeyev 0:e056ac8fecf8 1795 {
valeyev 0:e056ac8fecf8 1796 return _scanningParams.setInterval(interval);
valeyev 0:e056ac8fecf8 1797 }
valeyev 0:e056ac8fecf8 1798
valeyev 0:e056ac8fecf8 1799 /**
valeyev 0:e056ac8fecf8 1800 * Set the window parameter used during scanning procedures.
valeyev 0:e056ac8fecf8 1801 *
valeyev 0:e056ac8fecf8 1802 * @param[in] window Period in ms during which the scanner listens to
valeyev 0:e056ac8fecf8 1803 * advertising channels. That value is in the range 2.5ms to 10.24s.
valeyev 0:e056ac8fecf8 1804 *
valeyev 0:e056ac8fecf8 1805 * @return BLE_ERROR_NONE if the scan window was correctly set.
valeyev 0:e056ac8fecf8 1806 *
valeyev 0:e056ac8fecf8 1807 * @note If scanning is already active, the updated value of scanWindow
valeyev 0:e056ac8fecf8 1808 * is propagated to the underlying BLE stack.
valeyev 0:e056ac8fecf8 1809 */
valeyev 0:e056ac8fecf8 1810 ble_error_t setScanWindow(uint16_t window)
valeyev 0:e056ac8fecf8 1811 {
valeyev 0:e056ac8fecf8 1812 ble_error_t rc;
valeyev 0:e056ac8fecf8 1813 if ((rc = _scanningParams.setWindow(window)) != BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1814 return rc;
valeyev 0:e056ac8fecf8 1815 }
valeyev 0:e056ac8fecf8 1816
valeyev 0:e056ac8fecf8 1817 /* If scanning is already active, propagate the new setting to the stack. */
valeyev 0:e056ac8fecf8 1818 if (scanningActive) {
valeyev 0:e056ac8fecf8 1819 return startRadioScan(_scanningParams);
valeyev 0:e056ac8fecf8 1820 }
valeyev 0:e056ac8fecf8 1821
valeyev 0:e056ac8fecf8 1822 return BLE_ERROR_NONE;
valeyev 0:e056ac8fecf8 1823 }
valeyev 0:e056ac8fecf8 1824
valeyev 0:e056ac8fecf8 1825 /**
valeyev 0:e056ac8fecf8 1826 * Set the timeout parameter used during scanning procedures.
valeyev 0:e056ac8fecf8 1827 *
valeyev 0:e056ac8fecf8 1828 * @param[in] timeout Duration in seconds of the scan procedure if any. The
valeyev 0:e056ac8fecf8 1829 * special value 0 disables specific duration of the scan procedure.
valeyev 0:e056ac8fecf8 1830 *
valeyev 0:e056ac8fecf8 1831 * @return BLE_ERROR_NONE if the scan timeout was correctly set.
valeyev 0:e056ac8fecf8 1832 *
valeyev 0:e056ac8fecf8 1833 * @note If scanning is already active, the updated value of scanTimeout
valeyev 0:e056ac8fecf8 1834 * is propagated to the underlying BLE stack.
valeyev 0:e056ac8fecf8 1835 */
valeyev 0:e056ac8fecf8 1836 ble_error_t setScanTimeout(uint16_t timeout)
valeyev 0:e056ac8fecf8 1837 {
valeyev 0:e056ac8fecf8 1838 ble_error_t rc;
valeyev 0:e056ac8fecf8 1839 if ((rc = _scanningParams.setTimeout(timeout)) != BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1840 return rc;
valeyev 0:e056ac8fecf8 1841 }
valeyev 0:e056ac8fecf8 1842
valeyev 0:e056ac8fecf8 1843 /* If scanning is already active, propagate the new settings to the stack. */
valeyev 0:e056ac8fecf8 1844 if (scanningActive) {
valeyev 0:e056ac8fecf8 1845 return startRadioScan(_scanningParams);
valeyev 0:e056ac8fecf8 1846 }
valeyev 0:e056ac8fecf8 1847
valeyev 0:e056ac8fecf8 1848 return BLE_ERROR_NONE;
valeyev 0:e056ac8fecf8 1849 }
valeyev 0:e056ac8fecf8 1850
valeyev 0:e056ac8fecf8 1851 /**
valeyev 0:e056ac8fecf8 1852 * Enable or disable active scanning.
valeyev 0:e056ac8fecf8 1853 *
valeyev 0:e056ac8fecf8 1854 * @param[in] activeScanning If set to true, then the scanner sends scan
valeyev 0:e056ac8fecf8 1855 * requests to a scannable or connectable advertiser. If set to false then the
valeyev 0:e056ac8fecf8 1856 * scanner does not send any request during the scan procedure.
valeyev 0:e056ac8fecf8 1857 *
valeyev 0:e056ac8fecf8 1858 * @return BLE_ERROR_NONE if active scanning was successfully set.
valeyev 0:e056ac8fecf8 1859 *
valeyev 0:e056ac8fecf8 1860 * @note If scanning is already in progress, then active scanning is
valeyev 0:e056ac8fecf8 1861 * enabled for the underlying BLE stack.
valeyev 0:e056ac8fecf8 1862 */
valeyev 0:e056ac8fecf8 1863 ble_error_t setActiveScanning(bool activeScanning)
valeyev 0:e056ac8fecf8 1864 {
valeyev 0:e056ac8fecf8 1865 _scanningParams.setActiveScanning(activeScanning);
valeyev 0:e056ac8fecf8 1866
valeyev 0:e056ac8fecf8 1867 /* If scanning is already active, propagate the new settings to the stack. */
valeyev 0:e056ac8fecf8 1868 if (scanningActive) {
valeyev 0:e056ac8fecf8 1869 return startRadioScan(_scanningParams);
valeyev 0:e056ac8fecf8 1870 }
valeyev 0:e056ac8fecf8 1871
valeyev 0:e056ac8fecf8 1872 return BLE_ERROR_NONE;
valeyev 0:e056ac8fecf8 1873 }
valeyev 0:e056ac8fecf8 1874
valeyev 0:e056ac8fecf8 1875 /**
valeyev 0:e056ac8fecf8 1876 * Start the scanning procedure.
valeyev 0:e056ac8fecf8 1877 *
valeyev 0:e056ac8fecf8 1878 * Packets received during the scan procedure are forwarded to the
valeyev 0:e056ac8fecf8 1879 * scan packet handler passed as argument to this function.
valeyev 0:e056ac8fecf8 1880 *
valeyev 0:e056ac8fecf8 1881 * @param[in] callback Advertisement packet event handler. Upon reception
valeyev 0:e056ac8fecf8 1882 * of an advertising packet, the packet is forwarded to @p callback.
valeyev 0:e056ac8fecf8 1883 *
valeyev 0:e056ac8fecf8 1884 * @return BLE_ERROR_NONE if the device successfully started the scan
valeyev 0:e056ac8fecf8 1885 * procedure.
valeyev 0:e056ac8fecf8 1886 *
valeyev 0:e056ac8fecf8 1887 * @note The parameters used by the procedure are defined by setScanParams().
valeyev 0:e056ac8fecf8 1888 */
valeyev 0:e056ac8fecf8 1889 ble_error_t startScan(
valeyev 0:e056ac8fecf8 1890 void (*callback)(const AdvertisementCallbackParams_t *params)
valeyev 0:e056ac8fecf8 1891 ) {
valeyev 0:e056ac8fecf8 1892 ble_error_t err = BLE_ERROR_NONE;
valeyev 0:e056ac8fecf8 1893 if (callback) {
valeyev 0:e056ac8fecf8 1894 if ((err = startRadioScan(_scanningParams)) == BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1895 scanningActive = true;
valeyev 0:e056ac8fecf8 1896 onAdvertisementReport.attach(callback);
valeyev 0:e056ac8fecf8 1897 }
valeyev 0:e056ac8fecf8 1898 }
valeyev 0:e056ac8fecf8 1899
valeyev 0:e056ac8fecf8 1900 return err;
valeyev 0:e056ac8fecf8 1901 }
valeyev 0:e056ac8fecf8 1902
valeyev 0:e056ac8fecf8 1903 /**
valeyev 0:e056ac8fecf8 1904 * Start the scanning procedure.
valeyev 0:e056ac8fecf8 1905 *
valeyev 0:e056ac8fecf8 1906 * Packets received during the scan procedure are forwarded to the
valeyev 0:e056ac8fecf8 1907 * scan packet handler passed as argument to this function.
valeyev 0:e056ac8fecf8 1908 *
valeyev 0:e056ac8fecf8 1909 * @param[in] object Instance used to invoke @p callbackMember.
valeyev 0:e056ac8fecf8 1910 *
valeyev 0:e056ac8fecf8 1911 * @param[in] callbackMember Advertisement packet event handler. Upon
valeyev 0:e056ac8fecf8 1912 * reception of an advertising packet, the packet is forwarded to @p
valeyev 0:e056ac8fecf8 1913 * callback invoked from @p object.
valeyev 0:e056ac8fecf8 1914 *
valeyev 0:e056ac8fecf8 1915 * @return BLE_ERROR_NONE if the device successfully started the scan
valeyev 0:e056ac8fecf8 1916 * procedure.
valeyev 0:e056ac8fecf8 1917 *
valeyev 0:e056ac8fecf8 1918 * @note The parameters used by the procedure are defined by setScanParams().
valeyev 0:e056ac8fecf8 1919 */
valeyev 0:e056ac8fecf8 1920 template<typename T>
valeyev 0:e056ac8fecf8 1921 ble_error_t startScan(
valeyev 0:e056ac8fecf8 1922 T *object,
valeyev 0:e056ac8fecf8 1923 void (T::*callbackMember)(const AdvertisementCallbackParams_t *params)
valeyev 0:e056ac8fecf8 1924 ) {
valeyev 0:e056ac8fecf8 1925 ble_error_t err = BLE_ERROR_NONE;
valeyev 0:e056ac8fecf8 1926 if (object && callbackMember) {
valeyev 0:e056ac8fecf8 1927 if ((err = startRadioScan(_scanningParams)) == BLE_ERROR_NONE) {
valeyev 0:e056ac8fecf8 1928 scanningActive = true;
valeyev 0:e056ac8fecf8 1929 onAdvertisementReport.attach(object, callbackMember);
valeyev 0:e056ac8fecf8 1930 }
valeyev 0:e056ac8fecf8 1931 }
valeyev 0:e056ac8fecf8 1932
valeyev 0:e056ac8fecf8 1933 return err;
valeyev 0:e056ac8fecf8 1934 }
valeyev 0:e056ac8fecf8 1935
valeyev 0:e056ac8fecf8 1936 /**
valeyev 0:e056ac8fecf8 1937 * Enable radio-notification events.
valeyev 0:e056ac8fecf8 1938 *
valeyev 0:e056ac8fecf8 1939 * Radio Notification is a feature that notifies the application when the
valeyev 0:e056ac8fecf8 1940 * radio is in use.
valeyev 0:e056ac8fecf8 1941 *
valeyev 0:e056ac8fecf8 1942 * The ACTIVE signal is sent before the radio event starts. The nACTIVE
valeyev 0:e056ac8fecf8 1943 * signal is sent at the end of the radio event. The application programmer can
valeyev 0:e056ac8fecf8 1944 * use these signals to synchronize application logic with radio
valeyev 0:e056ac8fecf8 1945 * activity. For example, the ACTIVE signal can be used to shut off external
valeyev 0:e056ac8fecf8 1946 * devices, to manage peak current drawn during periods when the radio is on
valeyev 0:e056ac8fecf8 1947 * or to trigger sensor data collection for transmission in the Radio Event.
valeyev 0:e056ac8fecf8 1948 *
valeyev 0:e056ac8fecf8 1949 * @return BLE_ERROR_NONE on successful initialization, otherwise an error code.
valeyev 0:e056ac8fecf8 1950 */
valeyev 0:e056ac8fecf8 1951 virtual ble_error_t initRadioNotification(void)
valeyev 0:e056ac8fecf8 1952 {
valeyev 0:e056ac8fecf8 1953 /* Requesting action from porter(s): override this API if this capability
valeyev 0:e056ac8fecf8 1954 is supported. */
valeyev 0:e056ac8fecf8 1955 return BLE_ERROR_NOT_IMPLEMENTED;
valeyev 0:e056ac8fecf8 1956 }
valeyev 0:e056ac8fecf8 1957
valeyev 0:e056ac8fecf8 1958 private:
valeyev 0:e056ac8fecf8 1959 /**
valeyev 0:e056ac8fecf8 1960 * Set the advertising data and scan response in the vendor subsytem.
valeyev 0:e056ac8fecf8 1961 *
valeyev 0:e056ac8fecf8 1962 * @param[in] advData Advertising data to set.
valeyev 0:e056ac8fecf8 1963 * @param[in] scanResponse Scan response to set.
valeyev 0:e056ac8fecf8 1964 *
valeyev 0:e056ac8fecf8 1965 * @return BLE_ERROR_NONE if the advertising data was set successfully.
valeyev 0:e056ac8fecf8 1966 *
valeyev 0:e056ac8fecf8 1967 * @note Must be implemented in vendor port.
valeyev 0:e056ac8fecf8 1968 */
valeyev 0:e056ac8fecf8 1969 virtual ble_error_t setAdvertisingData(
valeyev 0:e056ac8fecf8 1970 const GapAdvertisingData &advData,
valeyev 0:e056ac8fecf8 1971 const GapAdvertisingData &scanResponse
valeyev 0:e056ac8fecf8 1972 ) = 0;
valeyev 0:e056ac8fecf8 1973
valeyev 0:e056ac8fecf8 1974 /**
valeyev 0:e056ac8fecf8 1975 * Start the advertising procedure.
valeyev 0:e056ac8fecf8 1976 *
valeyev 0:e056ac8fecf8 1977 * @param[in] params Advertising parameters to use.
valeyev 0:e056ac8fecf8 1978 *
valeyev 0:e056ac8fecf8 1979 * @return BLE_ERROR_NONE if the advertising procedure successfully
valeyev 0:e056ac8fecf8 1980 * started.
valeyev 0:e056ac8fecf8 1981 *
valeyev 0:e056ac8fecf8 1982 * @note Must be implemented in vendor port.
valeyev 0:e056ac8fecf8 1983 */
valeyev 0:e056ac8fecf8 1984 virtual ble_error_t startAdvertising(const GapAdvertisingParams &params) = 0;
valeyev 0:e056ac8fecf8 1985
valeyev 0:e056ac8fecf8 1986 public:
valeyev 0:e056ac8fecf8 1987 /**
valeyev 0:e056ac8fecf8 1988 * Get the current advertising parameters.
valeyev 0:e056ac8fecf8 1989 *
valeyev 0:e056ac8fecf8 1990 * @return A reference to the current advertising parameters.
valeyev 0:e056ac8fecf8 1991 */
valeyev 0:e056ac8fecf8 1992 GapAdvertisingParams &getAdvertisingParams(void)
valeyev 0:e056ac8fecf8 1993 {
valeyev 0:e056ac8fecf8 1994 return _advParams;
valeyev 0:e056ac8fecf8 1995 }
valeyev 0:e056ac8fecf8 1996
valeyev 0:e056ac8fecf8 1997 /**
valeyev 0:e056ac8fecf8 1998 * Const alternative to Gap::getAdvertisingParams().
valeyev 0:e056ac8fecf8 1999 *
valeyev 0:e056ac8fecf8 2000 * @return A const reference to the current advertising parameters.
valeyev 0:e056ac8fecf8 2001 */
valeyev 0:e056ac8fecf8 2002 const GapAdvertisingParams &getAdvertisingParams(void) const
valeyev 0:e056ac8fecf8 2003 {
valeyev 0:e056ac8fecf8 2004 return _advParams;
valeyev 0:e056ac8fecf8 2005 }
valeyev 0:e056ac8fecf8 2006
valeyev 0:e056ac8fecf8 2007 /**
valeyev 0:e056ac8fecf8 2008 * Set the advertising parameters.
valeyev 0:e056ac8fecf8 2009 *
valeyev 0:e056ac8fecf8 2010 * @param[in] newParams The new advertising parameters.
valeyev 0:e056ac8fecf8 2011 */
valeyev 0:e056ac8fecf8 2012 void setAdvertisingParams(const GapAdvertisingParams &newParams)
valeyev 0:e056ac8fecf8 2013 {
valeyev 0:e056ac8fecf8 2014 _advParams = newParams;
valeyev 0:e056ac8fecf8 2015 }
valeyev 0:e056ac8fecf8 2016
valeyev 0:e056ac8fecf8 2017 /* Event handlers. */
valeyev 0:e056ac8fecf8 2018 public:
valeyev 0:e056ac8fecf8 2019 /**
valeyev 0:e056ac8fecf8 2020 * Register a callback handling timeout events.
valeyev 0:e056ac8fecf8 2021 *
valeyev 0:e056ac8fecf8 2022 * @param[in] callback Event handler being registered.
valeyev 0:e056ac8fecf8 2023 *
valeyev 0:e056ac8fecf8 2024 * @note A callback may be unregistered using onTimeout().detach(callback).
valeyev 0:e056ac8fecf8 2025 *
valeyev 0:e056ac8fecf8 2026 * @see TimeoutSource_t
valeyev 0:e056ac8fecf8 2027 */
valeyev 0:e056ac8fecf8 2028 void onTimeout(TimeoutEventCallback_t callback)
valeyev 0:e056ac8fecf8 2029 {
valeyev 0:e056ac8fecf8 2030 timeoutCallbackChain.add(callback);
valeyev 0:e056ac8fecf8 2031 }
valeyev 0:e056ac8fecf8 2032
valeyev 0:e056ac8fecf8 2033 /**
valeyev 0:e056ac8fecf8 2034 * Get the callchain of registered timeout event handlers.
valeyev 0:e056ac8fecf8 2035 *
valeyev 0:e056ac8fecf8 2036 * @note To register callbacks, use onTimeout().add(callback).
valeyev 0:e056ac8fecf8 2037 *
valeyev 0:e056ac8fecf8 2038 * @note To unregister callbacks, use onTimeout().detach(callback).
valeyev 0:e056ac8fecf8 2039 *
valeyev 0:e056ac8fecf8 2040 * @return A reference to the timeout event callbacks chain.
valeyev 0:e056ac8fecf8 2041 */
valeyev 0:e056ac8fecf8 2042 TimeoutEventCallbackChain_t& onTimeout()
valeyev 0:e056ac8fecf8 2043 {
valeyev 0:e056ac8fecf8 2044 return timeoutCallbackChain;
valeyev 0:e056ac8fecf8 2045 }
valeyev 0:e056ac8fecf8 2046
valeyev 0:e056ac8fecf8 2047 /**
valeyev 0:e056ac8fecf8 2048 * Register a callback handling connection events.
valeyev 0:e056ac8fecf8 2049 *
valeyev 0:e056ac8fecf8 2050 * @param[in] callback Event handler being registered.
valeyev 0:e056ac8fecf8 2051 *
valeyev 0:e056ac8fecf8 2052 * @note A callback may be unregistered using onConnection().detach(callback).
valeyev 0:e056ac8fecf8 2053 */
valeyev 0:e056ac8fecf8 2054 void onConnection(ConnectionEventCallback_t callback)
valeyev 0:e056ac8fecf8 2055 {
valeyev 0:e056ac8fecf8 2056 connectionCallChain.add(callback);
valeyev 0:e056ac8fecf8 2057 }
valeyev 0:e056ac8fecf8 2058
valeyev 0:e056ac8fecf8 2059 /**
valeyev 0:e056ac8fecf8 2060 * Register a callback handling connection events.
valeyev 0:e056ac8fecf8 2061 *
valeyev 0:e056ac8fecf8 2062 * @param[in] tptr Instance used to invoke @p mptr.
valeyev 0:e056ac8fecf8 2063 * @param[in] mptr Event handler being registered.
valeyev 0:e056ac8fecf8 2064 *
valeyev 0:e056ac8fecf8 2065 * @note A callback may be unregistered using onConnection().detach(callback).
valeyev 0:e056ac8fecf8 2066 */
valeyev 0:e056ac8fecf8 2067 template<typename T>
valeyev 0:e056ac8fecf8 2068 void onConnection(T *tptr, void (T::*mptr)(const ConnectionCallbackParams_t*))
valeyev 0:e056ac8fecf8 2069 {
valeyev 0:e056ac8fecf8 2070 connectionCallChain.add(tptr, mptr);
valeyev 0:e056ac8fecf8 2071 }
valeyev 0:e056ac8fecf8 2072
valeyev 0:e056ac8fecf8 2073 /**
valeyev 0:e056ac8fecf8 2074 * Get the callchain of registered connection event handlers.
valeyev 0:e056ac8fecf8 2075 *
valeyev 0:e056ac8fecf8 2076 * @note To register callbacks, use onConnection().add(callback).
valeyev 0:e056ac8fecf8 2077 *
valeyev 0:e056ac8fecf8 2078 * @note To unregister callbacks, use onConnection().detach(callback).
valeyev 0:e056ac8fecf8 2079 *
valeyev 0:e056ac8fecf8 2080 * @return A reference to the connection event callbacks chain.
valeyev 0:e056ac8fecf8 2081 */
valeyev 0:e056ac8fecf8 2082 ConnectionEventCallbackChain_t& onConnection()
valeyev 0:e056ac8fecf8 2083 {
valeyev 0:e056ac8fecf8 2084 return connectionCallChain;
valeyev 0:e056ac8fecf8 2085 }
valeyev 0:e056ac8fecf8 2086
valeyev 0:e056ac8fecf8 2087 /**
valeyev 0:e056ac8fecf8 2088 * Register a callback handling disconnection events.
valeyev 0:e056ac8fecf8 2089 *
valeyev 0:e056ac8fecf8 2090 * @param[in] callback Event handler being registered.
valeyev 0:e056ac8fecf8 2091 *
valeyev 0:e056ac8fecf8 2092 * @note A callback may be unregistered using onDisconnection().detach(callback).
valeyev 0:e056ac8fecf8 2093 */
valeyev 0:e056ac8fecf8 2094 void onDisconnection(DisconnectionEventCallback_t callback)
valeyev 0:e056ac8fecf8 2095 {
valeyev 0:e056ac8fecf8 2096 disconnectionCallChain.add(callback);
valeyev 0:e056ac8fecf8 2097 }
valeyev 0:e056ac8fecf8 2098
valeyev 0:e056ac8fecf8 2099 /**
valeyev 0:e056ac8fecf8 2100 * Register a callback handling disconnection events.
valeyev 0:e056ac8fecf8 2101 *
valeyev 0:e056ac8fecf8 2102 * @param[in] tptr Instance used to invoke mptr.
valeyev 0:e056ac8fecf8 2103 * @param[in] mptr Event handler being registered.
valeyev 0:e056ac8fecf8 2104 *
valeyev 0:e056ac8fecf8 2105 * @note A callback may be unregistered using onDisconnection().detach(callback).
valeyev 0:e056ac8fecf8 2106 */
valeyev 0:e056ac8fecf8 2107 template<typename T>
valeyev 0:e056ac8fecf8 2108 void onDisconnection(T *tptr, void (T::*mptr)(const DisconnectionCallbackParams_t*))
valeyev 0:e056ac8fecf8 2109 {
valeyev 0:e056ac8fecf8 2110 disconnectionCallChain.add(tptr, mptr);
valeyev 0:e056ac8fecf8 2111 }
valeyev 0:e056ac8fecf8 2112
valeyev 0:e056ac8fecf8 2113 /**
valeyev 0:e056ac8fecf8 2114 * Get the callchain of registered disconnection event handlers.
valeyev 0:e056ac8fecf8 2115 *
valeyev 0:e056ac8fecf8 2116 * @note To register callbacks use onDisconnection().add(callback).
valeyev 0:e056ac8fecf8 2117 *
valeyev 0:e056ac8fecf8 2118 * @note To unregister callbacks use onDisconnection().detach(callback).
valeyev 0:e056ac8fecf8 2119 *
valeyev 0:e056ac8fecf8 2120 * @return A reference to the disconnection event callbacks chain.
valeyev 0:e056ac8fecf8 2121 */
valeyev 0:e056ac8fecf8 2122 DisconnectionEventCallbackChain_t& onDisconnection()
valeyev 0:e056ac8fecf8 2123 {
valeyev 0:e056ac8fecf8 2124 return disconnectionCallChain;
valeyev 0:e056ac8fecf8 2125 }
valeyev 0:e056ac8fecf8 2126
valeyev 0:e056ac8fecf8 2127 /**
valeyev 0:e056ac8fecf8 2128 * Set the radio-notification events handler.
valeyev 0:e056ac8fecf8 2129 *
valeyev 0:e056ac8fecf8 2130 * Radio Notification is a feature that enables ACTIVE and INACTIVE
valeyev 0:e056ac8fecf8 2131 * (nACTIVE) signals from the stack that notify the application when the
valeyev 0:e056ac8fecf8 2132 * radio is in use.
valeyev 0:e056ac8fecf8 2133 *
valeyev 0:e056ac8fecf8 2134 * The ACTIVE signal is sent before the radio event starts. The nACTIVE
valeyev 0:e056ac8fecf8 2135 * signal is sent at the end of the radio event. The application programmer can
valeyev 0:e056ac8fecf8 2136 * use these signals to synchronize application logic with radio
valeyev 0:e056ac8fecf8 2137 * activity. For example, the ACTIVE signal can be used to shut off external
valeyev 0:e056ac8fecf8 2138 * devices, to manage peak current drawn during periods when the radio is on
valeyev 0:e056ac8fecf8 2139 * or to trigger sensor data collection for transmission in the Radio Event.
valeyev 0:e056ac8fecf8 2140 *
valeyev 0:e056ac8fecf8 2141 * @param[in] callback Application handler to be invoked in response to a
valeyev 0:e056ac8fecf8 2142 * radio ACTIVE/INACTIVE event.
valeyev 0:e056ac8fecf8 2143 */
valeyev 0:e056ac8fecf8 2144 void onRadioNotification(void (*callback)(bool param))
valeyev 0:e056ac8fecf8 2145 {
valeyev 0:e056ac8fecf8 2146 radioNotificationCallback.attach(callback);
valeyev 0:e056ac8fecf8 2147 }
valeyev 0:e056ac8fecf8 2148
valeyev 0:e056ac8fecf8 2149 /**
valeyev 0:e056ac8fecf8 2150 * Set the radio-notification events handler.
valeyev 0:e056ac8fecf8 2151 *
valeyev 0:e056ac8fecf8 2152 * @param[in] tptr Instance to be used to invoke mptr.
valeyev 0:e056ac8fecf8 2153 * @param[in] mptr Application handler to be invoked in response to a
valeyev 0:e056ac8fecf8 2154 * radio ACTIVE/INACTIVE event.
valeyev 0:e056ac8fecf8 2155 */
valeyev 0:e056ac8fecf8 2156 template <typename T>
valeyev 0:e056ac8fecf8 2157 void onRadioNotification(T *tptr, void (T::*mptr)(bool))
valeyev 0:e056ac8fecf8 2158 {
valeyev 0:e056ac8fecf8 2159 radioNotificationCallback.attach(tptr, mptr);
valeyev 0:e056ac8fecf8 2160 }
valeyev 0:e056ac8fecf8 2161
valeyev 0:e056ac8fecf8 2162 /**
valeyev 0:e056ac8fecf8 2163 * Register a Gap shutdown event handler.
valeyev 0:e056ac8fecf8 2164 *
valeyev 0:e056ac8fecf8 2165 * The handler is called when the Gap instance is about to shut down.
valeyev 0:e056ac8fecf8 2166 * It is usually issued after a call to BLE::shutdown().
valeyev 0:e056ac8fecf8 2167 *
valeyev 0:e056ac8fecf8 2168 * @param[in] callback Shutdown event handler to register.
valeyev 0:e056ac8fecf8 2169 *
valeyev 0:e056ac8fecf8 2170 * @note To unregister a shutdown event handler, use
valeyev 0:e056ac8fecf8 2171 * onShutdown().detach(callback).
valeyev 0:e056ac8fecf8 2172 */
valeyev 0:e056ac8fecf8 2173 void onShutdown(const GapShutdownCallback_t& callback)
valeyev 0:e056ac8fecf8 2174 {
valeyev 0:e056ac8fecf8 2175 shutdownCallChain.add(callback);
valeyev 0:e056ac8fecf8 2176 }
valeyev 0:e056ac8fecf8 2177
valeyev 0:e056ac8fecf8 2178 /**
valeyev 0:e056ac8fecf8 2179 * Register a Gap shutdown event handler.
valeyev 0:e056ac8fecf8 2180 *
valeyev 0:e056ac8fecf8 2181 * @param[in] objPtr Instance used to invoke @p memberPtr.
valeyev 0:e056ac8fecf8 2182 * @param[in] memberPtr Shutdown event handler to register.
valeyev 0:e056ac8fecf8 2183 */
valeyev 0:e056ac8fecf8 2184 template <typename T>
valeyev 0:e056ac8fecf8 2185 void onShutdown(T *objPtr, void (T::*memberPtr)(const Gap *))
valeyev 0:e056ac8fecf8 2186 {
valeyev 0:e056ac8fecf8 2187 shutdownCallChain.add(objPtr, memberPtr);
valeyev 0:e056ac8fecf8 2188 }
valeyev 0:e056ac8fecf8 2189
valeyev 0:e056ac8fecf8 2190 /**
valeyev 0:e056ac8fecf8 2191 * Access the callchain of shutdown event handler.
valeyev 0:e056ac8fecf8 2192 *
valeyev 0:e056ac8fecf8 2193 * @note To register callbacks, use onShutdown().add(callback).
valeyev 0:e056ac8fecf8 2194 *
valeyev 0:e056ac8fecf8 2195 * @note To unregister callbacks, use onShutdown().detach(callback).
valeyev 0:e056ac8fecf8 2196 *
valeyev 0:e056ac8fecf8 2197 * @return A reference to the shutdown event callback chain.
valeyev 0:e056ac8fecf8 2198 */
valeyev 0:e056ac8fecf8 2199 GapShutdownCallbackChain_t& onShutdown()
valeyev 0:e056ac8fecf8 2200 {
valeyev 0:e056ac8fecf8 2201 return shutdownCallChain;
valeyev 0:e056ac8fecf8 2202 }
valeyev 0:e056ac8fecf8 2203
valeyev 0:e056ac8fecf8 2204 public:
valeyev 0:e056ac8fecf8 2205 /**
valeyev 0:e056ac8fecf8 2206 * Reset the Gap instance.
valeyev 0:e056ac8fecf8 2207 *
valeyev 0:e056ac8fecf8 2208 * Reset process starts by notifying all registered shutdown event handlers
valeyev 0:e056ac8fecf8 2209 * that the Gap instance is about to be shut down. Then, it clears all Gap state
valeyev 0:e056ac8fecf8 2210 * of the associated object and then cleans the state present in the vendor
valeyev 0:e056ac8fecf8 2211 * implementation.
valeyev 0:e056ac8fecf8 2212 *
valeyev 0:e056ac8fecf8 2213 * This function is meant to be overridden in the platform-specific
valeyev 0:e056ac8fecf8 2214 * subclass. Nevertheless, the subclass only resets its
valeyev 0:e056ac8fecf8 2215 * state and not the data held in Gap members. This is achieved by a
valeyev 0:e056ac8fecf8 2216 * call to Gap::reset() from the subclass' reset() implementation.
valeyev 0:e056ac8fecf8 2217 *
valeyev 0:e056ac8fecf8 2218 * @return BLE_ERROR_NONE on success.
valeyev 0:e056ac8fecf8 2219 *
valeyev 0:e056ac8fecf8 2220 * @note Currently, a call to reset() does not reset the advertising and
valeyev 0:e056ac8fecf8 2221 * scan parameters to default values.
valeyev 0:e056ac8fecf8 2222 */
valeyev 0:e056ac8fecf8 2223 virtual ble_error_t reset(void)
valeyev 0:e056ac8fecf8 2224 {
valeyev 0:e056ac8fecf8 2225 /* Notify that the instance is about to shut down */
valeyev 0:e056ac8fecf8 2226 shutdownCallChain.call(this);
valeyev 0:e056ac8fecf8 2227 shutdownCallChain.clear();
valeyev 0:e056ac8fecf8 2228
valeyev 0:e056ac8fecf8 2229 /* Clear Gap state */
valeyev 0:e056ac8fecf8 2230 state.advertising = 0;
valeyev 0:e056ac8fecf8 2231 state.connected = 0;
valeyev 0:e056ac8fecf8 2232 connectionCount = 0;
valeyev 0:e056ac8fecf8 2233
valeyev 0:e056ac8fecf8 2234 /* Clear scanning state */
valeyev 0:e056ac8fecf8 2235 scanningActive = false;
valeyev 0:e056ac8fecf8 2236
valeyev 0:e056ac8fecf8 2237 /* Clear advertising and scanning data */
valeyev 0:e056ac8fecf8 2238 _advPayload.clear();
valeyev 0:e056ac8fecf8 2239 _scanResponse.clear();
valeyev 0:e056ac8fecf8 2240
valeyev 0:e056ac8fecf8 2241 /* Clear callbacks */
valeyev 0:e056ac8fecf8 2242 timeoutCallbackChain.clear();
valeyev 0:e056ac8fecf8 2243 connectionCallChain.clear();
valeyev 0:e056ac8fecf8 2244 disconnectionCallChain.clear();
valeyev 0:e056ac8fecf8 2245 radioNotificationCallback = NULL;
valeyev 0:e056ac8fecf8 2246 onAdvertisementReport = NULL;
valeyev 0:e056ac8fecf8 2247
valeyev 0:e056ac8fecf8 2248 return BLE_ERROR_NONE;
valeyev 0:e056ac8fecf8 2249 }
valeyev 0:e056ac8fecf8 2250
valeyev 0:e056ac8fecf8 2251 protected:
valeyev 0:e056ac8fecf8 2252 /**
valeyev 0:e056ac8fecf8 2253 * Construct a Gap instance.
valeyev 0:e056ac8fecf8 2254 */
valeyev 0:e056ac8fecf8 2255 Gap() :
valeyev 0:e056ac8fecf8 2256 _advParams(),
valeyev 0:e056ac8fecf8 2257 _advPayload(),
valeyev 0:e056ac8fecf8 2258 _scanningParams(),
valeyev 0:e056ac8fecf8 2259 _scanResponse(),
valeyev 0:e056ac8fecf8 2260 connectionCount(0),
valeyev 0:e056ac8fecf8 2261 state(),
valeyev 0:e056ac8fecf8 2262 scanningActive(false),
valeyev 0:e056ac8fecf8 2263 timeoutCallbackChain(),
valeyev 0:e056ac8fecf8 2264 radioNotificationCallback(),
valeyev 0:e056ac8fecf8 2265 onAdvertisementReport(),
valeyev 0:e056ac8fecf8 2266 connectionCallChain(),
valeyev 0:e056ac8fecf8 2267 disconnectionCallChain() {
valeyev 0:e056ac8fecf8 2268 _advPayload.clear();
valeyev 0:e056ac8fecf8 2269 _scanResponse.clear();
valeyev 0:e056ac8fecf8 2270 }
valeyev 0:e056ac8fecf8 2271
valeyev 0:e056ac8fecf8 2272 /* Entry points for the underlying stack to report events back to the user. */
valeyev 0:e056ac8fecf8 2273 public:
valeyev 0:e056ac8fecf8 2274 /**
valeyev 0:e056ac8fecf8 2275 * Notify all registered connection event handlers of a connection event.
valeyev 0:e056ac8fecf8 2276 *
valeyev 0:e056ac8fecf8 2277 * @attention This function is meant to be called from the BLE stack specific
valeyev 0:e056ac8fecf8 2278 * implementation when a connection event occurs.
valeyev 0:e056ac8fecf8 2279 *
valeyev 0:e056ac8fecf8 2280 * @param[in] handle Handle of the new connection.
valeyev 0:e056ac8fecf8 2281 * @param[in] role Role of this BLE device in the connection.
valeyev 0:e056ac8fecf8 2282 * @param[in] peerAddrType Address type of the connected peer.
valeyev 0:e056ac8fecf8 2283 * @param[in] peerAddr Address of the connected peer.
valeyev 0:e056ac8fecf8 2284 * @param[in] ownAddrType Address type this device uses for this
valeyev 0:e056ac8fecf8 2285 * connection.
valeyev 0:e056ac8fecf8 2286 * @param[in] ownAddr Address this device uses for this connection.
valeyev 0:e056ac8fecf8 2287 * @param[in] connectionParams Parameters of the connection.
valeyev 0:e056ac8fecf8 2288 */
valeyev 0:e056ac8fecf8 2289 void processConnectionEvent(
valeyev 0:e056ac8fecf8 2290 Handle_t handle,
valeyev 0:e056ac8fecf8 2291 Role_t role,
valeyev 0:e056ac8fecf8 2292 BLEProtocol::AddressType_t peerAddrType,
valeyev 0:e056ac8fecf8 2293 const BLEProtocol::AddressBytes_t peerAddr,
valeyev 0:e056ac8fecf8 2294 BLEProtocol::AddressType_t ownAddrType,
valeyev 0:e056ac8fecf8 2295 const BLEProtocol::AddressBytes_t ownAddr,
valeyev 0:e056ac8fecf8 2296 const ConnectionParams_t *connectionParams
valeyev 0:e056ac8fecf8 2297 ) {
valeyev 0:e056ac8fecf8 2298 /* Update Gap state */
valeyev 0:e056ac8fecf8 2299 state.advertising = 0;
valeyev 0:e056ac8fecf8 2300 state.connected = 1;
valeyev 0:e056ac8fecf8 2301 ++connectionCount;
valeyev 0:e056ac8fecf8 2302
valeyev 0:e056ac8fecf8 2303 ConnectionCallbackParams_t callbackParams(
valeyev 0:e056ac8fecf8 2304 handle,
valeyev 0:e056ac8fecf8 2305 role,
valeyev 0:e056ac8fecf8 2306 peerAddrType,
valeyev 0:e056ac8fecf8 2307 peerAddr,
valeyev 0:e056ac8fecf8 2308 ownAddrType,
valeyev 0:e056ac8fecf8 2309 ownAddr,
valeyev 0:e056ac8fecf8 2310 connectionParams
valeyev 0:e056ac8fecf8 2311 );
valeyev 0:e056ac8fecf8 2312
valeyev 0:e056ac8fecf8 2313 connectionCallChain.call(&callbackParams);
valeyev 0:e056ac8fecf8 2314 }
valeyev 0:e056ac8fecf8 2315
valeyev 0:e056ac8fecf8 2316 /**
valeyev 0:e056ac8fecf8 2317 * Notify all registered disconnection event handlers of a disconnection event.
valeyev 0:e056ac8fecf8 2318 *
valeyev 0:e056ac8fecf8 2319 * @attention This function is meant to be called from the BLE stack specific
valeyev 0:e056ac8fecf8 2320 * implementation when a disconnection event occurs.
valeyev 0:e056ac8fecf8 2321 *
valeyev 0:e056ac8fecf8 2322 * @param[in] handle Handle of the terminated connection.
valeyev 0:e056ac8fecf8 2323 * @param[in] reason Reason of the disconnection.
valeyev 0:e056ac8fecf8 2324 */
valeyev 0:e056ac8fecf8 2325 void processDisconnectionEvent(Handle_t handle, DisconnectionReason_t reason)
valeyev 0:e056ac8fecf8 2326 {
valeyev 0:e056ac8fecf8 2327 /* Update Gap state */
valeyev 0:e056ac8fecf8 2328 --connectionCount;
valeyev 0:e056ac8fecf8 2329 if (!connectionCount) {
valeyev 0:e056ac8fecf8 2330 state.connected = 0;
valeyev 0:e056ac8fecf8 2331 }
valeyev 0:e056ac8fecf8 2332
valeyev 0:e056ac8fecf8 2333 DisconnectionCallbackParams_t callbackParams(handle, reason);
valeyev 0:e056ac8fecf8 2334 disconnectionCallChain.call(&callbackParams);
valeyev 0:e056ac8fecf8 2335 }
valeyev 0:e056ac8fecf8 2336
valeyev 0:e056ac8fecf8 2337 /**
valeyev 0:e056ac8fecf8 2338 * Forward a received advertising packet to all registered event handlers
valeyev 0:e056ac8fecf8 2339 * listening for scanned packet events.
valeyev 0:e056ac8fecf8 2340 *
valeyev 0:e056ac8fecf8 2341 * @attention This function is meant to be called from the BLE stack specific
valeyev 0:e056ac8fecf8 2342 * implementation when a disconnection event occurs.
valeyev 0:e056ac8fecf8 2343 *
valeyev 0:e056ac8fecf8 2344 * @param[in] peerAddr Address of the peer that has emitted the packet.
valeyev 0:e056ac8fecf8 2345 * @param[in] rssi Value of the RSSI measured for the received packet.
valeyev 0:e056ac8fecf8 2346 * @param[in] isScanResponse If true, then the packet is a response to a scan
valeyev 0:e056ac8fecf8 2347 * request.
valeyev 0:e056ac8fecf8 2348 * @param[in] type Advertising type of the packet.
valeyev 0:e056ac8fecf8 2349 * @param[in] advertisingDataLen Length of the advertisement data received.
valeyev 0:e056ac8fecf8 2350 * @param[in] advertisingData Pointer to the advertisement packet's data.
valeyev 0:e056ac8fecf8 2351 * @param[in] addressType Type of the address of the peer that has emitted the packet.
valeyev 0:e056ac8fecf8 2352 */
valeyev 0:e056ac8fecf8 2353 void processAdvertisementReport(
valeyev 0:e056ac8fecf8 2354 const BLEProtocol::AddressBytes_t peerAddr,
valeyev 0:e056ac8fecf8 2355 int8_t rssi,
valeyev 0:e056ac8fecf8 2356 bool isScanResponse,
valeyev 0:e056ac8fecf8 2357 GapAdvertisingParams::AdvertisingType_t type,
valeyev 0:e056ac8fecf8 2358 uint8_t advertisingDataLen,
valeyev 0:e056ac8fecf8 2359 const uint8_t *advertisingData,
valeyev 0:e056ac8fecf8 2360 BLEProtocol::AddressType_t addressType = BLEProtocol::AddressType::RANDOM_STATIC
valeyev 0:e056ac8fecf8 2361 ) {
valeyev 0:e056ac8fecf8 2362 // FIXME: remove default parameter for addressType when ST shield is merged;
valeyev 0:e056ac8fecf8 2363 // this has been added to mitigate the lack of dependency management in
valeyev 0:e056ac8fecf8 2364 // testing jobs ....
valeyev 0:e056ac8fecf8 2365
valeyev 0:e056ac8fecf8 2366 AdvertisementCallbackParams_t params;
valeyev 0:e056ac8fecf8 2367 memcpy(params.peerAddr, peerAddr, ADDR_LEN);
valeyev 0:e056ac8fecf8 2368 params.rssi = rssi;
valeyev 0:e056ac8fecf8 2369 params.isScanResponse = isScanResponse;
valeyev 0:e056ac8fecf8 2370 params.type = type;
valeyev 0:e056ac8fecf8 2371 params.advertisingDataLen = advertisingDataLen;
valeyev 0:e056ac8fecf8 2372 params.advertisingData = advertisingData;
valeyev 0:e056ac8fecf8 2373 params.addressType = addressType;
valeyev 0:e056ac8fecf8 2374 onAdvertisementReport.call(&params);
valeyev 0:e056ac8fecf8 2375 }
valeyev 0:e056ac8fecf8 2376
valeyev 0:e056ac8fecf8 2377 /**
valeyev 0:e056ac8fecf8 2378 * Notify the occurrence of a timeout event to all registered timeout events
valeyev 0:e056ac8fecf8 2379 * handler.
valeyev 0:e056ac8fecf8 2380 *
valeyev 0:e056ac8fecf8 2381 * @attention This function is meant to be called from the BLE stack specific
valeyev 0:e056ac8fecf8 2382 * implementation when a disconnection event occurs.
valeyev 0:e056ac8fecf8 2383 *
valeyev 0:e056ac8fecf8 2384 * @param[in] source Source of the timout event.
valeyev 0:e056ac8fecf8 2385 */
valeyev 0:e056ac8fecf8 2386 void processTimeoutEvent(TimeoutSource_t source)
valeyev 0:e056ac8fecf8 2387 {
valeyev 0:e056ac8fecf8 2388 if (source == TIMEOUT_SRC_ADVERTISING) {
valeyev 0:e056ac8fecf8 2389 /* Update gap state if the source is an advertising timeout */
valeyev 0:e056ac8fecf8 2390 state.advertising = 0;
valeyev 0:e056ac8fecf8 2391 }
valeyev 0:e056ac8fecf8 2392 if (timeoutCallbackChain) {
valeyev 0:e056ac8fecf8 2393 timeoutCallbackChain(source);
valeyev 0:e056ac8fecf8 2394 }
valeyev 0:e056ac8fecf8 2395 }
valeyev 0:e056ac8fecf8 2396
valeyev 0:e056ac8fecf8 2397 protected:
valeyev 0:e056ac8fecf8 2398 /**
valeyev 0:e056ac8fecf8 2399 * Current advertising parameters.
valeyev 0:e056ac8fecf8 2400 */
valeyev 0:e056ac8fecf8 2401 GapAdvertisingParams _advParams;
valeyev 0:e056ac8fecf8 2402
valeyev 0:e056ac8fecf8 2403 /**
valeyev 0:e056ac8fecf8 2404 * Current advertising data.
valeyev 0:e056ac8fecf8 2405 */
valeyev 0:e056ac8fecf8 2406 GapAdvertisingData _advPayload;
valeyev 0:e056ac8fecf8 2407
valeyev 0:e056ac8fecf8 2408 /**
valeyev 0:e056ac8fecf8 2409 * Current scanning parameters.
valeyev 0:e056ac8fecf8 2410 */
valeyev 0:e056ac8fecf8 2411 GapScanningParams _scanningParams;
valeyev 0:e056ac8fecf8 2412
valeyev 0:e056ac8fecf8 2413 /**
valeyev 0:e056ac8fecf8 2414 * Current scan response.
valeyev 0:e056ac8fecf8 2415 */
valeyev 0:e056ac8fecf8 2416 GapAdvertisingData _scanResponse;
valeyev 0:e056ac8fecf8 2417
valeyev 0:e056ac8fecf8 2418 /**
valeyev 0:e056ac8fecf8 2419 * Number of open connections.
valeyev 0:e056ac8fecf8 2420 */
valeyev 0:e056ac8fecf8 2421 uint8_t connectionCount;
valeyev 0:e056ac8fecf8 2422
valeyev 0:e056ac8fecf8 2423 /**
valeyev 0:e056ac8fecf8 2424 * Current GAP state.
valeyev 0:e056ac8fecf8 2425 */
valeyev 0:e056ac8fecf8 2426 GapState_t state;
valeyev 0:e056ac8fecf8 2427
valeyev 0:e056ac8fecf8 2428 /**
valeyev 0:e056ac8fecf8 2429 * Active scanning flag.
valeyev 0:e056ac8fecf8 2430 */
valeyev 0:e056ac8fecf8 2431 bool scanningActive;
valeyev 0:e056ac8fecf8 2432
valeyev 0:e056ac8fecf8 2433 protected:
valeyev 0:e056ac8fecf8 2434 /**
valeyev 0:e056ac8fecf8 2435 * Callchain containing all registered callback handlers for timeout
valeyev 0:e056ac8fecf8 2436 * events.
valeyev 0:e056ac8fecf8 2437 */
valeyev 0:e056ac8fecf8 2438 TimeoutEventCallbackChain_t timeoutCallbackChain;
valeyev 0:e056ac8fecf8 2439
valeyev 0:e056ac8fecf8 2440 /**
valeyev 0:e056ac8fecf8 2441 * The registered callback handler for radio notification events.
valeyev 0:e056ac8fecf8 2442 */
valeyev 0:e056ac8fecf8 2443 RadioNotificationEventCallback_t radioNotificationCallback;
valeyev 0:e056ac8fecf8 2444
valeyev 0:e056ac8fecf8 2445 /**
valeyev 0:e056ac8fecf8 2446 * The registered callback handler for scanned advertisement packet
valeyev 0:e056ac8fecf8 2447 * notifications.
valeyev 0:e056ac8fecf8 2448 */
valeyev 0:e056ac8fecf8 2449 AdvertisementReportCallback_t onAdvertisementReport;
valeyev 0:e056ac8fecf8 2450
valeyev 0:e056ac8fecf8 2451 /**
valeyev 0:e056ac8fecf8 2452 * Callchain containing all registered callback handlers for connection
valeyev 0:e056ac8fecf8 2453 * events.
valeyev 0:e056ac8fecf8 2454 */
valeyev 0:e056ac8fecf8 2455 ConnectionEventCallbackChain_t connectionCallChain;
valeyev 0:e056ac8fecf8 2456
valeyev 0:e056ac8fecf8 2457 /**
valeyev 0:e056ac8fecf8 2458 * Callchain containing all registered callback handlers for disconnection
valeyev 0:e056ac8fecf8 2459 * events.
valeyev 0:e056ac8fecf8 2460 */
valeyev 0:e056ac8fecf8 2461 DisconnectionEventCallbackChain_t disconnectionCallChain;
valeyev 0:e056ac8fecf8 2462
valeyev 0:e056ac8fecf8 2463 private:
valeyev 0:e056ac8fecf8 2464 /**
valeyev 0:e056ac8fecf8 2465 * Callchain containing all registered callback handlers for shutdown
valeyev 0:e056ac8fecf8 2466 * events.
valeyev 0:e056ac8fecf8 2467 */
valeyev 0:e056ac8fecf8 2468 GapShutdownCallbackChain_t shutdownCallChain;
valeyev 0:e056ac8fecf8 2469
valeyev 0:e056ac8fecf8 2470 private:
valeyev 0:e056ac8fecf8 2471 /* Disallow copy and assignment. */
valeyev 0:e056ac8fecf8 2472 Gap(const Gap &);
valeyev 0:e056ac8fecf8 2473 Gap& operator=(const Gap &);
valeyev 0:e056ac8fecf8 2474 };
valeyev 0:e056ac8fecf8 2475
valeyev 0:e056ac8fecf8 2476 /**
valeyev 0:e056ac8fecf8 2477 * @}
valeyev 0:e056ac8fecf8 2478 * @}
valeyev 0:e056ac8fecf8 2479 */
valeyev 0:e056ac8fecf8 2480
valeyev 0:e056ac8fecf8 2481 #endif // ifndef MBED_BLE_GAP_H__