iv123 lin / TARGET_ST_BLUENRG

ver:init

source/BlueNRGGattClient.cpp@0:88b85febcb45, 2017-06-18 (annotated)

Committer:
iv123
Date:
Sun Jun 18 16:10:28 2017 +0000
Revision:
0:88b85febcb45
Initial commit

Who changed what in which revision?

UserRevisionLine numberNew contents of line
iv123 0:88b85febcb45 1 /* mbed Microcontroller Library
iv123 0:88b85febcb45 2 * Copyright (c) 2006-2013 ARM Limited
iv123 0:88b85febcb45 3 *
iv123 0:88b85febcb45 4 * Licensed under the Apache License, Version 2.0 (the "License");
iv123 0:88b85febcb45 5 * you may not use this file except in compliance with the License.
iv123 0:88b85febcb45 6 * You may obtain a copy of the License at
iv123 0:88b85febcb45 7 *
iv123 0:88b85febcb45 8 * http://www.apache.org/licenses/LICENSE-2.0
iv123 0:88b85febcb45 9 *
iv123 0:88b85febcb45 10 * Unless required by applicable law or agreed to in writing, software
iv123 0:88b85febcb45 11 * distributed under the License is distributed on an "AS IS" BASIS,
iv123 0:88b85febcb45 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
iv123 0:88b85febcb45 13 * See the License for the specific language governing permissions and
iv123 0:88b85febcb45 14 * limitations under the License.
iv123 0:88b85febcb45 15 */
iv123 0:88b85febcb45 16 /**
iv123 0:88b85febcb45 17 ******************************************************************************
iv123 0:88b85febcb45 18 * @file BlueNRGGattServer.cpp
iv123 0:88b85febcb45 19 * @author STMicroelectronics
iv123 0:88b85febcb45 20 * @brief Implementation of BlueNRG BLE_API GattServer Class
iv123 0:88b85febcb45 21 ******************************************************************************
iv123 0:88b85febcb45 22 * @copy
iv123 0:88b85febcb45 23 *
iv123 0:88b85febcb45 24 * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
iv123 0:88b85febcb45 25 * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
iv123 0:88b85febcb45 26 * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
iv123 0:88b85febcb45 27 * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
iv123 0:88b85febcb45 28 * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
iv123 0:88b85febcb45 29 * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
iv123 0:88b85febcb45 30 *
iv123 0:88b85febcb45 31 * <h2><center>&copy; COPYRIGHT 2013 STMicroelectronics</center></h2>
iv123 0:88b85febcb45 32 */
iv123 0:88b85febcb45 33
iv123 0:88b85febcb45 34 /** @defgroup BlueNRGGATTClient
iv123 0:88b85febcb45 35 * @brief BlueNRG BLE_API GattClient Adaptation
iv123 0:88b85febcb45 36 * @{
iv123 0:88b85febcb45 37 */
iv123 0:88b85febcb45 38
iv123 0:88b85febcb45 39 #include "BlueNRGGattClient.h"
iv123 0:88b85febcb45 40 #ifdef YOTTA_CFG_MBED_OS
iv123 0:88b85febcb45 41 #include "mbed-drivers/mbed.h"
iv123 0:88b85febcb45 42 #else
iv123 0:88b85febcb45 43 #include "mbed.h"
iv123 0:88b85febcb45 44 #endif
iv123 0:88b85febcb45 45 #include "BlueNRGGap.h"
iv123 0:88b85febcb45 46 #include "ble_utils.h"
iv123 0:88b85febcb45 47 #include "ble_debug.h"
iv123 0:88b85febcb45 48
iv123 0:88b85febcb45 49 static uint8_t props_mask[] = {
iv123 0:88b85febcb45 50 0x01,
iv123 0:88b85febcb45 51 0x02,
iv123 0:88b85febcb45 52 0x04,
iv123 0:88b85febcb45 53 0x08,
iv123 0:88b85febcb45 54 0x10,
iv123 0:88b85febcb45 55 0x20,
iv123 0:88b85febcb45 56 0x40,
iv123 0:88b85febcb45 57 0x80
iv123 0:88b85febcb45 58 };
iv123 0:88b85febcb45 59
iv123 0:88b85febcb45 60 void BlueNRGGattClient::gattProcedureCompleteCB(Gap::Handle_t connectionHandle, uint8_t error_code)
iv123 0:88b85febcb45 61 {
iv123 0:88b85febcb45 62 if(error_code != BLE_STATUS_SUCCESS) {
iv123 0:88b85febcb45 63 _currentState = GATT_IDLE;
iv123 0:88b85febcb45 64 return;
iv123 0:88b85febcb45 65 }
iv123 0:88b85febcb45 66
iv123 0:88b85febcb45 67 // Service Discovery complete
iv123 0:88b85febcb45 68 /*
iv123 0:88b85febcb45 69 if(_currentState != GATT_IDLE &&
iv123 0:88b85febcb45 70 _currentState != GATT_DISCOVERY_TERMINATED &&
iv123 0:88b85febcb45 71 _currentState != GATT_WRITE_CHAR &&
iv123 0:88b85febcb45 72 _currentState != GATT_READ_CHAR) {
iv123 0:88b85febcb45 73 */
iv123 0:88b85febcb45 74 if(_currentState == GATT_SERVICE_DISCOVERY) {
iv123 0:88b85febcb45 75 findServiceChars(connectionHandle);
iv123 0:88b85febcb45 76 }
iv123 0:88b85febcb45 77
iv123 0:88b85febcb45 78 if(_currentState == GATT_CHAR_DESC_DISCOVERY) {
iv123 0:88b85febcb45 79 if(charDescTerminationCallback != NULL) {
iv123 0:88b85febcb45 80 CharacteristicDescriptorDiscovery::TerminationCallbackParams_t params = {
iv123 0:88b85febcb45 81 _characteristic,
iv123 0:88b85febcb45 82 BLE_ERROR_NONE
iv123 0:88b85febcb45 83 };
iv123 0:88b85febcb45 84 charDescTerminationCallback(&params);
iv123 0:88b85febcb45 85 }
iv123 0:88b85febcb45 86 _currentState = GATT_IDLE;
iv123 0:88b85febcb45 87 }
iv123 0:88b85febcb45 88
iv123 0:88b85febcb45 89 // Read complete
iv123 0:88b85febcb45 90 if(_currentState == GATT_READ_CHAR) {
iv123 0:88b85febcb45 91 _currentState = GATT_IDLE;
iv123 0:88b85febcb45 92 }
iv123 0:88b85febcb45 93
iv123 0:88b85febcb45 94 // Write complete
iv123 0:88b85febcb45 95 if(_currentState == GATT_WRITE_CHAR) {
iv123 0:88b85febcb45 96 BlueNRGGattClient::getInstance().processWriteResponse(&writeCBParams);
iv123 0:88b85febcb45 97 _currentState = GATT_IDLE;
iv123 0:88b85febcb45 98 }
iv123 0:88b85febcb45 99 }
iv123 0:88b85febcb45 100
iv123 0:88b85febcb45 101 void BlueNRGGattClient::primaryServicesCB(Gap::Handle_t connectionHandle,
iv123 0:88b85febcb45 102 uint8_t event_data_length,
iv123 0:88b85febcb45 103 uint8_t attribute_data_length,
iv123 0:88b85febcb45 104 uint8_t *attribute_data_list)
iv123 0:88b85febcb45 105 {
iv123 0:88b85febcb45 106 GattAttribute::Handle_t startHandle, endHandle;
iv123 0:88b85febcb45 107 UUID uuid;
iv123 0:88b85febcb45 108 uint8_t i, offset, numAttr;
iv123 0:88b85febcb45 109 /* avoid compiler warnings about unused variables */
iv123 0:88b85febcb45 110 (void)connectionHandle;
iv123 0:88b85febcb45 111
iv123 0:88b85febcb45 112 numAttr = (event_data_length - 1) / attribute_data_length;
iv123 0:88b85febcb45 113
iv123 0:88b85febcb45 114 offset = 0;
iv123 0:88b85febcb45 115 for (i=0; i<numAttr; i++) {
iv123 0:88b85febcb45 116 startHandle = attribute_data_list[offset];
iv123 0:88b85febcb45 117 endHandle = attribute_data_list[offset+2];
iv123 0:88b85febcb45 118
iv123 0:88b85febcb45 119 // UUID Type
iv123 0:88b85febcb45 120 if (attribute_data_length == 6) {
iv123 0:88b85febcb45 121
iv123 0:88b85febcb45 122 PRINTF("UUID_TYPE_16\n\r");
iv123 0:88b85febcb45 123 uuid = attribute_data_list[offset+5]<<8|attribute_data_list[offset+4];
iv123 0:88b85febcb45 124 PRINTF("S UUID-%X attrs[%u %u]\r\n", uuid.getShortUUID(), startHandle, endHandle);
iv123 0:88b85febcb45 125
iv123 0:88b85febcb45 126 } else {
iv123 0:88b85febcb45 127
iv123 0:88b85febcb45 128 PRINTF("UUID_TYPE_128\n\r");
iv123 0:88b85febcb45 129 uuid.setupLong(attribute_data_list+offset+4, UUID::LSB);
iv123 0:88b85febcb45 130
iv123 0:88b85febcb45 131 #ifdef DEBUG
iv123 0:88b85febcb45 132 PRINTF("S UUID-");
iv123 0:88b85febcb45 133 const uint8_t *longUUIDBytes = uuid.getBaseUUID();
iv123 0:88b85febcb45 134 for (unsigned j = 0; j < UUID::LENGTH_OF_LONG_UUID; j++) {
iv123 0:88b85febcb45 135 PRINTF("%02x", longUUIDBytes[j]);
iv123 0:88b85febcb45 136 }
iv123 0:88b85febcb45 137 #endif
iv123 0:88b85febcb45 138 PRINTF(" attrs[%u %u]\r\n", startHandle, endHandle);
iv123 0:88b85febcb45 139
iv123 0:88b85febcb45 140 }
iv123 0:88b85febcb45 141
iv123 0:88b85febcb45 142 PRINTF("Setup serviceIndex = %d\n\r", _numServices);
iv123 0:88b85febcb45 143 discoveredService[_numServices].setup(uuid, startHandle, endHandle);
iv123 0:88b85febcb45 144
iv123 0:88b85febcb45 145 _numServices++;
iv123 0:88b85febcb45 146
iv123 0:88b85febcb45 147 offset += attribute_data_length;
iv123 0:88b85febcb45 148 }
iv123 0:88b85febcb45 149
iv123 0:88b85febcb45 150 PRINTF("!!!Service Discovery complete (numAttr=%u)!!!\n\r", numAttr);
iv123 0:88b85febcb45 151
iv123 0:88b85febcb45 152 }
iv123 0:88b85febcb45 153
iv123 0:88b85febcb45 154 void BlueNRGGattClient::primaryServiceCB(Gap::Handle_t connectionHandle,
iv123 0:88b85febcb45 155 uint8_t event_data_length,
iv123 0:88b85febcb45 156 uint8_t *handles_info_list)
iv123 0:88b85febcb45 157 {
iv123 0:88b85febcb45 158 GattAttribute::Handle_t startHandle, endHandle;
iv123 0:88b85febcb45 159 UUID uuid;
iv123 0:88b85febcb45 160 uint8_t i, offset, numHandlePairs;
iv123 0:88b85febcb45 161 /* avoid compiler warnings about unused variables */
iv123 0:88b85febcb45 162 (void)connectionHandle;
iv123 0:88b85febcb45 163
iv123 0:88b85febcb45 164 numHandlePairs = (event_data_length - 1) / 2;
iv123 0:88b85febcb45 165
iv123 0:88b85febcb45 166 offset = 0;
iv123 0:88b85febcb45 167 for (i=0; i<numHandlePairs; i++) {
iv123 0:88b85febcb45 168 startHandle = handles_info_list[offset];
iv123 0:88b85febcb45 169 endHandle = handles_info_list[offset+2];
iv123 0:88b85febcb45 170
iv123 0:88b85febcb45 171 PRINTF("primaryServiceCB attrs[%u %u]\r\n", startHandle, endHandle);
iv123 0:88b85febcb45 172
iv123 0:88b85febcb45 173
iv123 0:88b85febcb45 174 if (_matchingServiceUUID.shortOrLong() == UUID::UUID_TYPE_SHORT) {
iv123 0:88b85febcb45 175 PRINTF("S UUID-%x attrs[%u %u]\r\n", _matchingServiceUUID.getShortUUID(), startHandle, endHandle);
iv123 0:88b85febcb45 176 uuid = _matchingServiceUUID.getShortUUID();
iv123 0:88b85febcb45 177 } else {
iv123 0:88b85febcb45 178 #ifdef DEBUG
iv123 0:88b85febcb45 179 PRINTF("S UUID-");
iv123 0:88b85febcb45 180 const uint8_t *longUUIDBytes = _matchingServiceUUID.getBaseUUID();
iv123 0:88b85febcb45 181 for (unsigned i = 0; i < UUID::LENGTH_OF_LONG_UUID; i++) {
iv123 0:88b85febcb45 182 PRINTF("%02x", longUUIDBytes[i]);
iv123 0:88b85febcb45 183 }
iv123 0:88b85febcb45 184 #endif
iv123 0:88b85febcb45 185 PRINTF(" attrs[%u %u]\r\n", startHandle, endHandle);
iv123 0:88b85febcb45 186 uuid.setupLong(_matchingServiceUUID.getBaseUUID(), UUID::MSB);
iv123 0:88b85febcb45 187 }
iv123 0:88b85febcb45 188
iv123 0:88b85febcb45 189 discoveredService[i].setup(uuid, startHandle, endHandle);
iv123 0:88b85febcb45 190
iv123 0:88b85febcb45 191 _numServices++;
iv123 0:88b85febcb45 192
iv123 0:88b85febcb45 193 offset += 4;
iv123 0:88b85febcb45 194 }
iv123 0:88b85febcb45 195 }
iv123 0:88b85febcb45 196
iv123 0:88b85febcb45 197 void BlueNRGGattClient::serviceCharsCB(Gap::Handle_t connectionHandle,
iv123 0:88b85febcb45 198 uint8_t event_data_length,
iv123 0:88b85febcb45 199 uint8_t handle_value_pair_length,
iv123 0:88b85febcb45 200 uint8_t *handle_value_pair)
iv123 0:88b85febcb45 201 {
iv123 0:88b85febcb45 202 // Charac Handle (2), Charac Properties(1), Charac Value Handle(2), Charac UUID(2/16)
iv123 0:88b85febcb45 203
iv123 0:88b85febcb45 204 GattAttribute::Handle_t declHandle, valueHandle, lastHandle;
iv123 0:88b85febcb45 205 UUID uuid;
iv123 0:88b85febcb45 206 uint8_t i, numChar, offset;
iv123 0:88b85febcb45 207
iv123 0:88b85febcb45 208 numChar = (event_data_length - 1) / handle_value_pair_length;
iv123 0:88b85febcb45 209
iv123 0:88b85febcb45 210 PRINTF("event_data_length=%d handle_value_pair_length=%d numChar=%d\n\r", event_data_length, handle_value_pair_length, numChar);
iv123 0:88b85febcb45 211
iv123 0:88b85febcb45 212 offset = 0;
iv123 0:88b85febcb45 213 for (i=0; i<numChar; i++) {
iv123 0:88b85febcb45 214 // UUID Type
iv123 0:88b85febcb45 215 if (handle_value_pair_length == 7) {
iv123 0:88b85febcb45 216 PRINTF("Char UUID_TYPE_16\n\r");
iv123 0:88b85febcb45 217 uuid = handle_value_pair[offset+6]<<8|handle_value_pair[offset+5];
iv123 0:88b85febcb45 218 PRINTF("C UUID-%X\r\n", uuid.getShortUUID());
iv123 0:88b85febcb45 219 } else {
iv123 0:88b85febcb45 220 PRINTF("Char UUID_TYPE_128\n\r");
iv123 0:88b85febcb45 221 uuid.setupLong(handle_value_pair+offset+5, UUID::LSB);
iv123 0:88b85febcb45 222 #ifdef DEBUG
iv123 0:88b85febcb45 223 PRINTF("C UUID-");
iv123 0:88b85febcb45 224 const uint8_t *longUUIDBytes = uuid.getBaseUUID();
iv123 0:88b85febcb45 225 for (unsigned i = 0; i < UUID::LENGTH_OF_LONG_UUID; i++) {
iv123 0:88b85febcb45 226 PRINTF("%02X", longUUIDBytes[i]);
iv123 0:88b85febcb45 227 }
iv123 0:88b85febcb45 228 PRINTF("\r\n");
iv123 0:88b85febcb45 229 #endif
iv123 0:88b85febcb45 230 }
iv123 0:88b85febcb45 231
iv123 0:88b85febcb45 232 // Properties
iv123 0:88b85febcb45 233 DiscoveredCharacteristic::Properties_t p;
iv123 0:88b85febcb45 234
iv123 0:88b85febcb45 235 p._broadcast = (props_mask[0] & handle_value_pair[offset+2]);
iv123 0:88b85febcb45 236 p._read = (props_mask[1] & handle_value_pair[offset+2])>>1;
iv123 0:88b85febcb45 237 p._writeWoResp = (props_mask[2] & handle_value_pair[offset+2])>>2;
iv123 0:88b85febcb45 238 p._write = (props_mask[3] & handle_value_pair[offset+2])>>3;
iv123 0:88b85febcb45 239 p._notify = (props_mask[4] & handle_value_pair[offset+2])>>4;
iv123 0:88b85febcb45 240 p._indicate = (props_mask[5] & handle_value_pair[offset+2])>>5;
iv123 0:88b85febcb45 241 p._authSignedWrite = (props_mask[6] & handle_value_pair[offset+2])>>6;
iv123 0:88b85febcb45 242 PRINTF("p._broadcast=%d\n\r", p._broadcast);
iv123 0:88b85febcb45 243 PRINTF("p._read=%d\n\r", p._read);
iv123 0:88b85febcb45 244 PRINTF("p._writeWoResp=%d\n\r", p._writeWoResp);
iv123 0:88b85febcb45 245 PRINTF("p._write=%d\n\r", p._write);
iv123 0:88b85febcb45 246 PRINTF("p._notify=%d\n\r", p._notify);
iv123 0:88b85febcb45 247 PRINTF("p._indicate=%d\n\r", p._indicate);
iv123 0:88b85febcb45 248 PRINTF("p._authSignedWrite=%d\n\r", p._authSignedWrite);
iv123 0:88b85febcb45 249
iv123 0:88b85febcb45 250 /*
iv123 0:88b85febcb45 251 uint8_t props = handle_value_pair[offset+2];
iv123 0:88b85febcb45 252 PRINTF("CHAR PROPS: %d\n\r", props);
iv123 0:88b85febcb45 253 */
iv123 0:88b85febcb45 254
iv123 0:88b85febcb45 255 // Handles
iv123 0:88b85febcb45 256 declHandle = handle_value_pair[offset];
iv123 0:88b85febcb45 257 valueHandle = handle_value_pair[offset+3];
iv123 0:88b85febcb45 258 lastHandle = valueHandle+1;
iv123 0:88b85febcb45 259 PRINTF("declHandle: %u valueHandle=%u lastHandle=%u\n\r", declHandle, valueHandle, lastHandle);
iv123 0:88b85febcb45 260
iv123 0:88b85febcb45 261 discoveredChar[_numChars].setup(this,
iv123 0:88b85febcb45 262 connectionHandle,
iv123 0:88b85febcb45 263 uuid,
iv123 0:88b85febcb45 264 p,
iv123 0:88b85febcb45 265 declHandle,
iv123 0:88b85febcb45 266 valueHandle,
iv123 0:88b85febcb45 267 lastHandle);
iv123 0:88b85febcb45 268
iv123 0:88b85febcb45 269 if (_numChars != 0) {
iv123 0:88b85febcb45 270 discoveredChar[_numChars - 1].setLastHandle(declHandle - 1);
iv123 0:88b85febcb45 271
iv123 0:88b85febcb45 272 if(characteristicDiscoveryCallback) {
iv123 0:88b85febcb45 273 characteristicDiscoveryCallback(&discoveredChar[_numChars - 1]);
iv123 0:88b85febcb45 274 }
iv123 0:88b85febcb45 275 }
iv123 0:88b85febcb45 276
iv123 0:88b85febcb45 277 _numChars++;
iv123 0:88b85febcb45 278
iv123 0:88b85febcb45 279 offset += handle_value_pair_length;
iv123 0:88b85febcb45 280 }
iv123 0:88b85febcb45 281 }
iv123 0:88b85febcb45 282
iv123 0:88b85febcb45 283 void BlueNRGGattClient::serviceCharByUUIDCB(Gap::Handle_t connectionHandle,
iv123 0:88b85febcb45 284 uint8_t event_data_length,
iv123 0:88b85febcb45 285 uint16_t attr_handle,
iv123 0:88b85febcb45 286 uint8_t *attr_value)
iv123 0:88b85febcb45 287 {
iv123 0:88b85febcb45 288 // Charac Properties(1), Charac Value Handle(2), Charac UUID(2/16)
iv123 0:88b85febcb45 289 GattAttribute::Handle_t declHandle, valueHandle, lastHandle;
iv123 0:88b85febcb45 290 UUID uuid;
iv123 0:88b85febcb45 291
iv123 0:88b85febcb45 292 PRINTF("serviceCharByUUIDCB\n\r");
iv123 0:88b85febcb45 293
iv123 0:88b85febcb45 294 // UUID Type
iv123 0:88b85febcb45 295 if (event_data_length == 7) {
iv123 0:88b85febcb45 296 PRINTF("Char UUID_TYPE_16\n\r");
iv123 0:88b85febcb45 297 uuid = attr_value[4]<<8|attr_value[3];
iv123 0:88b85febcb45 298 PRINTF("C UUID-%X\r\n", uuid.getShortUUID());
iv123 0:88b85febcb45 299 } else {
iv123 0:88b85febcb45 300 PRINTF("Char UUID_TYPE_128\n\r");
iv123 0:88b85febcb45 301 uuid.setupLong(attr_value+3, UUID::LSB);
iv123 0:88b85febcb45 302 #ifdef DEBUG
iv123 0:88b85febcb45 303 PRINTF("C UUID-");
iv123 0:88b85febcb45 304 const uint8_t *longUUIDBytes = uuid.getBaseUUID();
iv123 0:88b85febcb45 305 for (unsigned i = 0; i < UUID::LENGTH_OF_LONG_UUID; i++) {
iv123 0:88b85febcb45 306 PRINTF("%02X", longUUIDBytes[i]);
iv123 0:88b85febcb45 307 }
iv123 0:88b85febcb45 308 PRINTF("\r\n");
iv123 0:88b85febcb45 309 #endif
iv123 0:88b85febcb45 310 }
iv123 0:88b85febcb45 311
iv123 0:88b85febcb45 312 // Properties
iv123 0:88b85febcb45 313 DiscoveredCharacteristic::Properties_t p;
iv123 0:88b85febcb45 314
iv123 0:88b85febcb45 315 p._broadcast = (props_mask[0] & attr_value[0]);
iv123 0:88b85febcb45 316 p._read = (props_mask[1] & attr_value[0])>>1;
iv123 0:88b85febcb45 317 p._writeWoResp = (props_mask[2] & attr_value[0])>>2;
iv123 0:88b85febcb45 318 p._write = (props_mask[3] & attr_value[0])>>3;
iv123 0:88b85febcb45 319 p._notify = (props_mask[4] & attr_value[0])>>4;
iv123 0:88b85febcb45 320 p._indicate = (props_mask[5] & attr_value[0])>>5;
iv123 0:88b85febcb45 321 p._authSignedWrite = (props_mask[6] & attr_value[0])>>6;
iv123 0:88b85febcb45 322 PRINTF("p._broadcast=%d\n\r", p._broadcast);
iv123 0:88b85febcb45 323 PRINTF("p._read=%d\n\r", p._read);
iv123 0:88b85febcb45 324 PRINTF("p._writeWoResp=%d\n\r", p._writeWoResp);
iv123 0:88b85febcb45 325 PRINTF("p._write=%d\n\r", p._write);
iv123 0:88b85febcb45 326 PRINTF("p._notify=%d\n\r", p._notify);
iv123 0:88b85febcb45 327 PRINTF("p._indicate=%d\n\r", p._indicate);
iv123 0:88b85febcb45 328 PRINTF("p._authSignedWrite=%d\n\r", p._authSignedWrite);
iv123 0:88b85febcb45 329
iv123 0:88b85febcb45 330 /*
iv123 0:88b85febcb45 331 uint8_t props = attr_value[0];
iv123 0:88b85febcb45 332 PRINTF("CHAR PROPS: %d\n\r", props);
iv123 0:88b85febcb45 333 */
iv123 0:88b85febcb45 334
iv123 0:88b85febcb45 335 // Handles
iv123 0:88b85febcb45 336 declHandle = attr_handle;
iv123 0:88b85febcb45 337 valueHandle = attr_value[1];
iv123 0:88b85febcb45 338 lastHandle = valueHandle+1;
iv123 0:88b85febcb45 339
iv123 0:88b85febcb45 340 discoveredChar[_numChars].setup(this,
iv123 0:88b85febcb45 341 connectionHandle,
iv123 0:88b85febcb45 342 uuid,
iv123 0:88b85febcb45 343 p,
iv123 0:88b85febcb45 344 declHandle,
iv123 0:88b85febcb45 345 valueHandle,
iv123 0:88b85febcb45 346 lastHandle);
iv123 0:88b85febcb45 347
iv123 0:88b85febcb45 348 if(characteristicDiscoveryCallback) {
iv123 0:88b85febcb45 349 characteristicDiscoveryCallback(&discoveredChar[_numChars]);
iv123 0:88b85febcb45 350 }
iv123 0:88b85febcb45 351 _numChars++;
iv123 0:88b85febcb45 352 }
iv123 0:88b85febcb45 353
iv123 0:88b85febcb45 354 ble_error_t BlueNRGGattClient::findServiceChars(Gap::Handle_t connectionHandle)
iv123 0:88b85febcb45 355 {
iv123 0:88b85febcb45 356 PRINTF("findServiceChars\n\r");
iv123 0:88b85febcb45 357
iv123 0:88b85febcb45 358 tBleStatus ret;
iv123 0:88b85febcb45 359 uint8_t uuid_type = UUID_TYPE_16;
iv123 0:88b85febcb45 360 uint8_t short_uuid[2];
iv123 0:88b85febcb45 361 uint8_t *uuid = NULL;
iv123 0:88b85febcb45 362
iv123 0:88b85febcb45 363 DiscoveredService *service;
iv123 0:88b85febcb45 364
iv123 0:88b85febcb45 365 // complete the discovery of the last characteristic of the previous service.
iv123 0:88b85febcb45 366 // Its last handle wasn't known before this point
iv123 0:88b85febcb45 367 // update the handle and call the characteristic discovery callback.
iv123 0:88b85febcb45 368 if (_servIndex != 0 && _numChars != 0) {
iv123 0:88b85febcb45 369 discoveredChar[_numChars - 1].setLastHandle(discoveredService[_servIndex - 1].getEndHandle());
iv123 0:88b85febcb45 370
iv123 0:88b85febcb45 371 if(characteristicDiscoveryCallback) {
iv123 0:88b85febcb45 372 characteristicDiscoveryCallback(&discoveredChar[_numChars - 1]);
iv123 0:88b85febcb45 373 }
iv123 0:88b85febcb45 374 }
iv123 0:88b85febcb45 375
iv123 0:88b85febcb45 376 _numChars = 0;
iv123 0:88b85febcb45 377
iv123 0:88b85febcb45 378 // We finished chars discovery for all services
iv123 0:88b85febcb45 379 if(_servIndex >= _numServices) {
iv123 0:88b85febcb45 380 PRINTF("!!!We finished chars discovery for all services!!!\n\r");
iv123 0:88b85febcb45 381 //_currentState = GATT_CHARS_DISCOVERY_COMPLETE;
iv123 0:88b85febcb45 382
iv123 0:88b85febcb45 383 terminateServiceDiscovery();
iv123 0:88b85febcb45 384
iv123 0:88b85febcb45 385 return BLE_ERROR_NONE;
iv123 0:88b85febcb45 386 }
iv123 0:88b85febcb45 387
iv123 0:88b85febcb45 388 service = &discoveredService[_servIndex];
iv123 0:88b85febcb45 389 /*
iv123 0:88b85febcb45 390 if (service->getUUID().shortOrLong() == UUID::UUID_TYPE_SHORT) {
iv123 0:88b85febcb45 391 PRINTF("S UUID-%X\r\n", service->getUUID().getShortUUID());
iv123 0:88b85febcb45 392 } else {
iv123 0:88b85febcb45 393 PRINTF("S UUID-");
iv123 0:88b85febcb45 394 const uint8_t *longUUIDBytes = service->getUUID().getBaseUUID();
iv123 0:88b85febcb45 395 for (unsigned i = 0; i < UUID::LENGTH_OF_LONG_UUID; i++) {
iv123 0:88b85febcb45 396 PRINTF("%02X", longUUIDBytes[i]);
iv123 0:88b85febcb45 397 }
iv123 0:88b85febcb45 398 PRINTF("\r\n");
iv123 0:88b85febcb45 399 }
iv123 0:88b85febcb45 400 */
iv123 0:88b85febcb45 401
iv123 0:88b85febcb45 402 if(serviceDiscoveryCallback) {
iv123 0:88b85febcb45 403 serviceDiscoveryCallback(service);
iv123 0:88b85febcb45 404 }
iv123 0:88b85febcb45 405
iv123 0:88b85febcb45 406 PRINTF("findServiceChars (_servIndex=%d)\n\r", _servIndex);
iv123 0:88b85febcb45 407 //ret = aci_gatt_disc_all_charac_of_serv(connectionHandle, service->getStartHandle(), service->getEndHandle());
iv123 0:88b85febcb45 408
iv123 0:88b85febcb45 409 if(_matchingCharacteristicUUIDIn == BLE_UUID_UNKNOWN) {
iv123 0:88b85febcb45 410 PRINTF("findServiceChars (BLE_UUID_UNKNOWN)\n\r");
iv123 0:88b85febcb45 411 ret = aci_gatt_disc_all_charac_of_serv(connectionHandle, service->getStartHandle(), service->getEndHandle());
iv123 0:88b85febcb45 412 } else {
iv123 0:88b85febcb45 413
iv123 0:88b85febcb45 414 uint8_t type = _matchingCharacteristicUUIDIn.shortOrLong();
iv123 0:88b85febcb45 415
iv123 0:88b85febcb45 416 if(type == UUID::UUID_TYPE_SHORT) {
iv123 0:88b85febcb45 417 STORE_LE_16(short_uuid, _matchingCharacteristicUUIDIn.getShortUUID());
iv123 0:88b85febcb45 418
iv123 0:88b85febcb45 419 uuid_type = UUID_TYPE_16;
iv123 0:88b85febcb45 420 uuid = short_uuid;
iv123 0:88b85febcb45 421 #ifdef DEBUG
iv123 0:88b85febcb45 422 PRINTF("findServiceChars C UUID-");
iv123 0:88b85febcb45 423 for(unsigned i = 0; i < 2; i++) {
iv123 0:88b85febcb45 424 PRINTF("%02X", short_uuid[i]);
iv123 0:88b85febcb45 425 }
iv123 0:88b85febcb45 426 PRINTF("\n\r");
iv123 0:88b85febcb45 427 #endif
iv123 0:88b85febcb45 428 } else if(type==UUID::UUID_TYPE_LONG) {
iv123 0:88b85febcb45 429
iv123 0:88b85febcb45 430 uuid_type = UUID_TYPE_128;
iv123 0:88b85febcb45 431 uuid = (unsigned char*)_matchingCharacteristicUUIDIn.getBaseUUID();
iv123 0:88b85febcb45 432 #ifdef DEBUG
iv123 0:88b85febcb45 433 PRINTF("(findServiceChars) C UUID-");
iv123 0:88b85febcb45 434 for (unsigned i = 0; i < UUID::LENGTH_OF_LONG_UUID; i++) {
iv123 0:88b85febcb45 435 PRINTF("%02X", uuid[i]);
iv123 0:88b85febcb45 436 }
iv123 0:88b85febcb45 437 PRINTF("\r\n");
iv123 0:88b85febcb45 438 #endif
iv123 0:88b85febcb45 439 }
iv123 0:88b85febcb45 440
iv123 0:88b85febcb45 441 ret = aci_gatt_disc_charac_by_uuid(connectionHandle,
iv123 0:88b85febcb45 442 service->getStartHandle(),
iv123 0:88b85febcb45 443 service->getEndHandle(),
iv123 0:88b85febcb45 444 uuid_type,
iv123 0:88b85febcb45 445 uuid);
iv123 0:88b85febcb45 446 }
iv123 0:88b85febcb45 447
iv123 0:88b85febcb45 448 if(ret == BLE_STATUS_SUCCESS) {
iv123 0:88b85febcb45 449 _servIndex++;
iv123 0:88b85febcb45 450 }
iv123 0:88b85febcb45 451
iv123 0:88b85febcb45 452 PRINTF("findServiceChars ret=%d\n\r", ret);
iv123 0:88b85febcb45 453
iv123 0:88b85febcb45 454 return BLE_ERROR_NONE;
iv123 0:88b85febcb45 455 }
iv123 0:88b85febcb45 456
iv123 0:88b85febcb45 457 ble_error_t BlueNRGGattClient::launchServiceDiscovery(Gap::Handle_t connectionHandle,
iv123 0:88b85febcb45 458 ServiceDiscovery::ServiceCallback_t sc,
iv123 0:88b85febcb45 459 ServiceDiscovery::CharacteristicCallback_t cc,
iv123 0:88b85febcb45 460 const UUID &matchingServiceUUID,
iv123 0:88b85febcb45 461 const UUID &matchingCharacteristicUUIDIn)
iv123 0:88b85febcb45 462 {
iv123 0:88b85febcb45 463 PRINTF("launchServiceDiscovery\n\r");
iv123 0:88b85febcb45 464
iv123 0:88b85febcb45 465 tBleStatus ret;
iv123 0:88b85febcb45 466 uint8_t uuid_type = UUID_TYPE_16;
iv123 0:88b85febcb45 467 uint8_t short_uuid[2];
iv123 0:88b85febcb45 468 uint8_t *uuid = NULL;
iv123 0:88b85febcb45 469 unsigned j;
iv123 0:88b85febcb45 470
iv123 0:88b85febcb45 471 if(isServiceDiscoveryActive()) {
iv123 0:88b85febcb45 472 return BLE_ERROR_OPERATION_NOT_PERMITTED;
iv123 0:88b85febcb45 473 }
iv123 0:88b85febcb45 474
iv123 0:88b85febcb45 475 if(!sc && !cc) {
iv123 0:88b85febcb45 476 // nothing to do
iv123 0:88b85febcb45 477 PRINTF("launchServiceDiscovery: nothing to do\n\r");
iv123 0:88b85febcb45 478 return BLE_ERROR_NONE;
iv123 0:88b85febcb45 479 }
iv123 0:88b85febcb45 480
iv123 0:88b85febcb45 481 _connectionHandle = connectionHandle;
iv123 0:88b85febcb45 482 serviceDiscoveryCallback = sc;
iv123 0:88b85febcb45 483 characteristicDiscoveryCallback = cc;
iv123 0:88b85febcb45 484 _matchingServiceUUID = matchingServiceUUID;
iv123 0:88b85febcb45 485 _matchingCharacteristicUUIDIn = matchingCharacteristicUUIDIn;
iv123 0:88b85febcb45 486
iv123 0:88b85febcb45 487 //reset services
iv123 0:88b85febcb45 488 _numServices = 0;
iv123 0:88b85febcb45 489 _numChars = 0;
iv123 0:88b85febcb45 490 _servIndex = 0;
iv123 0:88b85febcb45 491 for(j = 0; j < BLE_TOTAL_DISCOVERED_SERVICES; j++) {
iv123 0:88b85febcb45 492 discoveredService[j].setup(BLE_UUID_UNKNOWN, GattAttribute::INVALID_HANDLE, GattAttribute::INVALID_HANDLE);
iv123 0:88b85febcb45 493 }
iv123 0:88b85febcb45 494
iv123 0:88b85febcb45 495 if(matchingServiceUUID == BLE_UUID_UNKNOWN) {
iv123 0:88b85febcb45 496
iv123 0:88b85febcb45 497 // Wildcard: search for all services
iv123 0:88b85febcb45 498 ret = aci_gatt_disc_all_prim_services((uint16_t)connectionHandle);
iv123 0:88b85febcb45 499
iv123 0:88b85febcb45 500 } else {
iv123 0:88b85febcb45 501
iv123 0:88b85febcb45 502 uint8_t type = matchingServiceUUID.shortOrLong();
iv123 0:88b85febcb45 503 //PRINTF("AddService(): Type:%d\n\r", type);
iv123 0:88b85febcb45 504
iv123 0:88b85febcb45 505 if(type == UUID::UUID_TYPE_SHORT) {
iv123 0:88b85febcb45 506 STORE_LE_16(short_uuid, matchingServiceUUID.getShortUUID());
iv123 0:88b85febcb45 507 #ifdef DEBUG
iv123 0:88b85febcb45 508 PRINTF("launchServiceDiscovery short_uuid=0x");
iv123 0:88b85febcb45 509 for(j = 0; j < 2; j++) {
iv123 0:88b85febcb45 510 PRINTF("%02X", short_uuid[j]);
iv123 0:88b85febcb45 511 }
iv123 0:88b85febcb45 512 PRINTF("\n\r");
iv123 0:88b85febcb45 513 #endif
iv123 0:88b85febcb45 514
iv123 0:88b85febcb45 515 uuid_type = UUID_TYPE_16;
iv123 0:88b85febcb45 516 uuid = short_uuid;
iv123 0:88b85febcb45 517
iv123 0:88b85febcb45 518 } else if(type==UUID::UUID_TYPE_LONG) {
iv123 0:88b85febcb45 519
iv123 0:88b85febcb45 520 uuid_type = UUID_TYPE_128;
iv123 0:88b85febcb45 521 uuid = (unsigned char*)matchingServiceUUID.getBaseUUID();
iv123 0:88b85febcb45 522
iv123 0:88b85febcb45 523 #ifdef DEBUG
iv123 0:88b85febcb45 524 PRINTF("launchServiceDiscovery base_uuid=0x");
iv123 0:88b85febcb45 525 for(j = 0; j < 16; j++) {
iv123 0:88b85febcb45 526 PRINTF("%02X", uuid[j]);
iv123 0:88b85febcb45 527 }
iv123 0:88b85febcb45 528 PRINTF("\n\r");
iv123 0:88b85febcb45 529 #endif
iv123 0:88b85febcb45 530 }
iv123 0:88b85febcb45 531
iv123 0:88b85febcb45 532 // search for specific service by UUID
iv123 0:88b85febcb45 533 ret = aci_gatt_disc_prim_service_by_uuid((uint16_t)connectionHandle, uuid_type, uuid);
iv123 0:88b85febcb45 534 //ret = aci_gatt_disc_all_prim_services((uint16_t)connectionHandle);
iv123 0:88b85febcb45 535 }
iv123 0:88b85febcb45 536
iv123 0:88b85febcb45 537 if(ret == BLE_STATUS_SUCCESS) {
iv123 0:88b85febcb45 538 _currentState = GATT_SERVICE_DISCOVERY;
iv123 0:88b85febcb45 539 }
iv123 0:88b85febcb45 540
iv123 0:88b85febcb45 541 PRINTF("launchServiceDiscovery ret=%d\n\r", ret);
iv123 0:88b85febcb45 542
iv123 0:88b85febcb45 543 return BLE_ERROR_NONE;
iv123 0:88b85febcb45 544 }
iv123 0:88b85febcb45 545
iv123 0:88b85febcb45 546 ble_error_t BlueNRGGattClient::discoverServices(Gap::Handle_t connectionHandle,
iv123 0:88b85febcb45 547 ServiceDiscovery::ServiceCallback_t callback,
iv123 0:88b85febcb45 548 const UUID &matchingServiceUUID)
iv123 0:88b85febcb45 549 {
iv123 0:88b85febcb45 550 /* avoid compiler warnings about unused variables */
iv123 0:88b85febcb45 551 (void)connectionHandle;
iv123 0:88b85febcb45 552 (void)callback;
iv123 0:88b85febcb45 553 (void)matchingServiceUUID;
iv123 0:88b85febcb45 554
iv123 0:88b85febcb45 555 return BLE_ERROR_NOT_IMPLEMENTED;
iv123 0:88b85febcb45 556 }
iv123 0:88b85febcb45 557
iv123 0:88b85febcb45 558 ble_error_t BlueNRGGattClient::discoverServices(Gap::Handle_t connectionHandle,
iv123 0:88b85febcb45 559 ServiceDiscovery::ServiceCallback_t callback,
iv123 0:88b85febcb45 560 GattAttribute::Handle_t startHandle,
iv123 0:88b85febcb45 561 GattAttribute::Handle_t endHandle)
iv123 0:88b85febcb45 562 {
iv123 0:88b85febcb45 563 /* avoid compiler warnings about unused variables */
iv123 0:88b85febcb45 564 (void)connectionHandle;
iv123 0:88b85febcb45 565 (void)callback;
iv123 0:88b85febcb45 566 (void)startHandle;
iv123 0:88b85febcb45 567 (void)endHandle;
iv123 0:88b85febcb45 568
iv123 0:88b85febcb45 569 return BLE_ERROR_NOT_IMPLEMENTED;
iv123 0:88b85febcb45 570 }
iv123 0:88b85febcb45 571
iv123 0:88b85febcb45 572 bool BlueNRGGattClient::isServiceDiscoveryActive(void) const
iv123 0:88b85febcb45 573 {
iv123 0:88b85febcb45 574 if(_currentState == GATT_SERVICE_DISCOVERY) {
iv123 0:88b85febcb45 575 return true;
iv123 0:88b85febcb45 576 }
iv123 0:88b85febcb45 577
iv123 0:88b85febcb45 578 return false;
iv123 0:88b85febcb45 579 /*
iv123 0:88b85febcb45 580 if(_currentState == GATT_IDLE ||
iv123 0:88b85febcb45 581 _currentState == GATT_DISCOVERY_TERMINATED ||
iv123 0:88b85febcb45 582 _currentState == GATT_READ_CHAR ||
iv123 0:88b85febcb45 583 _currentState == GATT_WRITE_CHAR ) {
iv123 0:88b85febcb45 584 return false;
iv123 0:88b85febcb45 585 }
iv123 0:88b85febcb45 586
iv123 0:88b85febcb45 587 return true;
iv123 0:88b85febcb45 588 */
iv123 0:88b85febcb45 589 }
iv123 0:88b85febcb45 590
iv123 0:88b85febcb45 591 void BlueNRGGattClient::terminateServiceDiscovery(void)
iv123 0:88b85febcb45 592 {
iv123 0:88b85febcb45 593 _currentState = GATT_IDLE;//GATT_DISCOVERY_TERMINATED;
iv123 0:88b85febcb45 594
iv123 0:88b85febcb45 595 if (terminationCallback) {
iv123 0:88b85febcb45 596 terminationCallback(_connectionHandle);
iv123 0:88b85febcb45 597 }
iv123 0:88b85febcb45 598 }
iv123 0:88b85febcb45 599
iv123 0:88b85febcb45 600 void BlueNRGGattClient::charReadCB(Gap::Handle_t connHandle,
iv123 0:88b85febcb45 601 uint8_t event_data_length,
iv123 0:88b85febcb45 602 uint8_t* attribute_value)
iv123 0:88b85febcb45 603 {
iv123 0:88b85febcb45 604 readCBParams.connHandle = connHandle;
iv123 0:88b85febcb45 605 readCBParams.offset = 0;
iv123 0:88b85febcb45 606 readCBParams.len = event_data_length;
iv123 0:88b85febcb45 607 readCBParams.data = attribute_value;
iv123 0:88b85febcb45 608
iv123 0:88b85febcb45 609 BlueNRGGattClient::getInstance().processReadResponse(&readCBParams);
iv123 0:88b85febcb45 610 }
iv123 0:88b85febcb45 611
iv123 0:88b85febcb45 612 ble_error_t BlueNRGGattClient::read(Gap::Handle_t connHandle, GattAttribute::Handle_t attributeHandle, uint16_t offset) const
iv123 0:88b85febcb45 613 {
iv123 0:88b85febcb45 614 /* avoid compiler warnings about unused variables */
iv123 0:88b85febcb45 615 (void)offset;
iv123 0:88b85febcb45 616
iv123 0:88b85febcb45 617 tBleStatus ret;
iv123 0:88b85febcb45 618
iv123 0:88b85febcb45 619 BlueNRGGattClient *gattc = const_cast<BlueNRGGattClient*>(this);
iv123 0:88b85febcb45 620
iv123 0:88b85febcb45 621 // Save the attribute_handle not provided by evt_att_read_resp
iv123 0:88b85febcb45 622 gattc->readCBParams.handle = attributeHandle;
iv123 0:88b85febcb45 623
iv123 0:88b85febcb45 624 // FIXME: We need to wait for a while before starting a read
iv123 0:88b85febcb45 625 // due to BlueNRG process queue handling
iv123 0:88b85febcb45 626 Clock_Wait(100);
iv123 0:88b85febcb45 627
iv123 0:88b85febcb45 628 ret = aci_gatt_read_charac_val(connHandle, attributeHandle);
iv123 0:88b85febcb45 629
iv123 0:88b85febcb45 630 if(ret == BLE_STATUS_SUCCESS) {
iv123 0:88b85febcb45 631 gattc->_currentState = GATT_READ_CHAR;
iv123 0:88b85febcb45 632 return BLE_ERROR_NONE;
iv123 0:88b85febcb45 633 }
iv123 0:88b85febcb45 634 switch (ret) {
iv123 0:88b85febcb45 635 case BLE_STATUS_BUSY:
iv123 0:88b85febcb45 636 return BLE_STACK_BUSY;
iv123 0:88b85febcb45 637 default:
iv123 0:88b85febcb45 638 return BLE_ERROR_INVALID_STATE;
iv123 0:88b85febcb45 639 }
iv123 0:88b85febcb45 640 }
iv123 0:88b85febcb45 641
iv123 0:88b85febcb45 642 void BlueNRGGattClient::charWritePrepareCB(Gap::Handle_t connHandle,
iv123 0:88b85febcb45 643 uint8_t event_data_length,
iv123 0:88b85febcb45 644 uint16_t attribute_handle,
iv123 0:88b85febcb45 645 uint16_t offset,
iv123 0:88b85febcb45 646 uint8_t *part_attr_value)
iv123 0:88b85febcb45 647 {
iv123 0:88b85febcb45 648 /* avoid compiler warnings about unused variables */
iv123 0:88b85febcb45 649 (void)connHandle;
iv123 0:88b85febcb45 650
iv123 0:88b85febcb45 651 // Update the write response params
iv123 0:88b85febcb45 652 writeCBParams.handle = attribute_handle;
iv123 0:88b85febcb45 653 writeCBParams.offset = offset;
iv123 0:88b85febcb45 654 writeCBParams.len = event_data_length-4; //(?)
iv123 0:88b85febcb45 655 writeCBParams.data = part_attr_value;
iv123 0:88b85febcb45 656
iv123 0:88b85febcb45 657 BlueNRGGattClient::getInstance().processWriteResponse(&writeCBParams);
iv123 0:88b85febcb45 658 }
iv123 0:88b85febcb45 659
iv123 0:88b85febcb45 660 void BlueNRGGattClient::charWriteExecCB(Gap::Handle_t connHandle,
iv123 0:88b85febcb45 661 uint8_t event_data_length)
iv123 0:88b85febcb45 662 {
iv123 0:88b85febcb45 663 /* avoid compiler warnings about unused variables */
iv123 0:88b85febcb45 664 (void)event_data_length;
iv123 0:88b85febcb45 665
iv123 0:88b85febcb45 666 writeCBParams.connHandle = connHandle;
iv123 0:88b85febcb45 667
iv123 0:88b85febcb45 668 BlueNRGGattClient::getInstance().processWriteResponse(&writeCBParams);
iv123 0:88b85febcb45 669 }
iv123 0:88b85febcb45 670
iv123 0:88b85febcb45 671 ble_error_t BlueNRGGattClient::write(GattClient::WriteOp_t cmd,
iv123 0:88b85febcb45 672 Gap::Handle_t connHandle,
iv123 0:88b85febcb45 673 GattAttribute::Handle_t attributeHandle,
iv123 0:88b85febcb45 674 size_t length,
iv123 0:88b85febcb45 675 const uint8_t *value) const
iv123 0:88b85febcb45 676 {
iv123 0:88b85febcb45 677 /* avoid compiler warnings about unused variables */
iv123 0:88b85febcb45 678 (void)cmd;
iv123 0:88b85febcb45 679
iv123 0:88b85febcb45 680 tBleStatus ret;
iv123 0:88b85febcb45 681
iv123 0:88b85febcb45 682 BlueNRGGattClient *gattc = const_cast<BlueNRGGattClient*>(this);
iv123 0:88b85febcb45 683
iv123 0:88b85febcb45 684 // We save the write response params (used by the callback) because
iv123 0:88b85febcb45 685 // when the aci_gatt_write_charac_value() is used the only event received is the EVT_BLUE_GATT_PROCEDURE_COMPLETE
iv123 0:88b85febcb45 686 gattc->writeCBParams.connHandle = connHandle;
iv123 0:88b85febcb45 687 gattc->writeCBParams.writeOp = GattWriteCallbackParams::OP_WRITE_CMD;
iv123 0:88b85febcb45 688 gattc->writeCBParams.handle = attributeHandle;
iv123 0:88b85febcb45 689 gattc->writeCBParams.offset = 0;
iv123 0:88b85febcb45 690 gattc->writeCBParams.len = length;
iv123 0:88b85febcb45 691 gattc->writeCBParams.data = value;
iv123 0:88b85febcb45 692
iv123 0:88b85febcb45 693 ret = aci_gatt_write_charac_value(connHandle, attributeHandle, length, const_cast<uint8_t *>(value));
iv123 0:88b85febcb45 694 //ret = aci_gatt_write_charac_reliable(connHandle, attributeHandle, 0, length, const_cast<uint8_t *>(value));
iv123 0:88b85febcb45 695
iv123 0:88b85febcb45 696 if (ret == BLE_STATUS_SUCCESS) {
iv123 0:88b85febcb45 697 gattc->_currentState = GATT_WRITE_CHAR;
iv123 0:88b85febcb45 698 return BLE_ERROR_NONE;
iv123 0:88b85febcb45 699 }
iv123 0:88b85febcb45 700 switch (ret) {
iv123 0:88b85febcb45 701 case BLE_STATUS_BUSY:
iv123 0:88b85febcb45 702 return BLE_STACK_BUSY;
iv123 0:88b85febcb45 703 default:
iv123 0:88b85febcb45 704 return BLE_ERROR_INVALID_STATE;
iv123 0:88b85febcb45 705 }
iv123 0:88b85febcb45 706
iv123 0:88b85febcb45 707 }
iv123 0:88b85febcb45 708
iv123 0:88b85febcb45 709 void BlueNRGGattClient::discAllCharacDescCB(Gap::Handle_t connHandle,
iv123 0:88b85febcb45 710 uint8_t event_data_length,
iv123 0:88b85febcb45 711 uint8_t format,
iv123 0:88b85febcb45 712 uint8_t *handle_uuid_pair) {
iv123 0:88b85febcb45 713 GattAttribute::Handle_t attHandle;
iv123 0:88b85febcb45 714 UUID uuid;
iv123 0:88b85febcb45 715 uint8_t i, numCharacDesc, offset, handle_uuid_length;
iv123 0:88b85febcb45 716
iv123 0:88b85febcb45 717 handle_uuid_length = 4; //Handle + UUID_16
iv123 0:88b85febcb45 718 if (format == 2)
iv123 0:88b85febcb45 719 handle_uuid_length = 18; //Handle + UUID_128
iv123 0:88b85febcb45 720
iv123 0:88b85febcb45 721 numCharacDesc = (event_data_length - 1) / handle_uuid_length;
iv123 0:88b85febcb45 722
iv123 0:88b85febcb45 723 offset = 0;
iv123 0:88b85febcb45 724
iv123 0:88b85febcb45 725 PRINTF("\r\ncharacteristic descriptor discovered: data length %u, format %u\r\n",
iv123 0:88b85febcb45 726 event_data_length, format);
iv123 0:88b85febcb45 727
iv123 0:88b85febcb45 728
iv123 0:88b85febcb45 729 for (i=0; i<numCharacDesc; i++) {
iv123 0:88b85febcb45 730 memcpy(&attHandle, handle_uuid_pair + offset, sizeof(attHandle));
iv123 0:88b85febcb45 731
iv123 0:88b85febcb45 732 // UUID Type
iv123 0:88b85febcb45 733 if (handle_uuid_length == 4) {
iv123 0:88b85febcb45 734
iv123 0:88b85febcb45 735 PRINTF("UUID_TYPE_16\n\r");
iv123 0:88b85febcb45 736 uuid = handle_uuid_pair[offset+3]<<8|handle_uuid_pair[offset+2];
iv123 0:88b85febcb45 737 PRINTF("D UUID-%X attHandle=%u\r\n", uuid.getShortUUID(), attHandle);
iv123 0:88b85febcb45 738
iv123 0:88b85febcb45 739 } else {
iv123 0:88b85febcb45 740
iv123 0:88b85febcb45 741 PRINTF("UUID_TYPE_128\n\r");
iv123 0:88b85febcb45 742 uuid.setupLong(handle_uuid_pair+offset+2, UUID::LSB);
iv123 0:88b85febcb45 743 #ifdef DEBUG
iv123 0:88b85febcb45 744 PRINTF("D UUID-");
iv123 0:88b85febcb45 745 const uint8_t *longUUIDBytes = uuid.getBaseUUID();
iv123 0:88b85febcb45 746 for (unsigned j = 0; j < UUID::LENGTH_OF_LONG_UUID; j++) {
iv123 0:88b85febcb45 747 PRINTF("%02x", longUUIDBytes[j]);
iv123 0:88b85febcb45 748 }
iv123 0:88b85febcb45 749 #endif
iv123 0:88b85febcb45 750 }
iv123 0:88b85febcb45 751
iv123 0:88b85febcb45 752 if(charDescDiscoveryCallback != NULL) {
iv123 0:88b85febcb45 753 CharacteristicDescriptorDiscovery::DiscoveryCallbackParams_t params = {
iv123 0:88b85febcb45 754 _characteristic,
iv123 0:88b85febcb45 755 DiscoveredCharacteristicDescriptor(
iv123 0:88b85febcb45 756 _characteristic.getGattClient(),
iv123 0:88b85febcb45 757 connHandle,
iv123 0:88b85febcb45 758 attHandle,
iv123 0:88b85febcb45 759 uuid
iv123 0:88b85febcb45 760 )
iv123 0:88b85febcb45 761 };
iv123 0:88b85febcb45 762 charDescDiscoveryCallback(&params);
iv123 0:88b85febcb45 763 }
iv123 0:88b85febcb45 764
iv123 0:88b85febcb45 765 _numCharDesc++;
iv123 0:88b85febcb45 766
iv123 0:88b85febcb45 767 offset += handle_uuid_length;
iv123 0:88b85febcb45 768 }
iv123 0:88b85febcb45 769 }
iv123 0:88b85febcb45 770
iv123 0:88b85febcb45 771 ble_error_t BlueNRGGattClient::discoverCharacteristicDescriptors(
iv123 0:88b85febcb45 772 const DiscoveredCharacteristic& characteristic,
iv123 0:88b85febcb45 773 const CharacteristicDescriptorDiscovery::DiscoveryCallback_t& discoveryCallback,
iv123 0:88b85febcb45 774 const CharacteristicDescriptorDiscovery::TerminationCallback_t& terminationCallback) {
iv123 0:88b85febcb45 775
iv123 0:88b85febcb45 776 tBleStatus ret;
iv123 0:88b85febcb45 777
iv123 0:88b85febcb45 778 if(_currentState != GATT_IDLE) {
iv123 0:88b85febcb45 779 return BLE_ERROR_OPERATION_NOT_PERMITTED;
iv123 0:88b85febcb45 780 }
iv123 0:88b85febcb45 781
iv123 0:88b85febcb45 782 charDescDiscoveryCallback = discoveryCallback;
iv123 0:88b85febcb45 783 charDescTerminationCallback = terminationCallback;
iv123 0:88b85febcb45 784
iv123 0:88b85febcb45 785 Gap::Handle_t connHandle = characteristic.getConnectionHandle();
iv123 0:88b85febcb45 786 GattAttribute::Handle_t valueHandle = characteristic.getValueHandle();
iv123 0:88b85febcb45 787 GattAttribute::Handle_t lastHandle = characteristic.getLastHandle();
iv123 0:88b85febcb45 788
iv123 0:88b85febcb45 789 PRINTF("Starting aci_gatt_disc_all_charac_descriptors... [%u : %u]\n\r", valueHandle, lastHandle);
iv123 0:88b85febcb45 790 ret = aci_gatt_disc_all_charac_descriptors(connHandle, valueHandle, lastHandle);
iv123 0:88b85febcb45 791
iv123 0:88b85febcb45 792 if (ret == BLE_STATUS_SUCCESS) {
iv123 0:88b85febcb45 793 _currentState = GATT_CHAR_DESC_DISCOVERY;
iv123 0:88b85febcb45 794 _characteristic = characteristic;
iv123 0:88b85febcb45 795 return BLE_ERROR_NONE;
iv123 0:88b85febcb45 796 }
iv123 0:88b85febcb45 797 switch (ret) {
iv123 0:88b85febcb45 798 case BLE_STATUS_INVALID_PARAMS:
iv123 0:88b85febcb45 799 return BLE_ERROR_INVALID_PARAM;
iv123 0:88b85febcb45 800 default:
iv123 0:88b85febcb45 801 return BLE_ERROR_OPERATION_NOT_PERMITTED;
iv123 0:88b85febcb45 802 }
iv123 0:88b85febcb45 803 }
iv123 0:88b85febcb45 804
iv123 0:88b85febcb45 805 /**************************************************************************/
iv123 0:88b85febcb45 806 /*!
iv123 0:88b85febcb45 807 @brief Clear BlueNRGGattServer's state.
iv123 0:88b85febcb45 808
iv123 0:88b85febcb45 809 @returns ble_error_t
iv123 0:88b85febcb45 810
iv123 0:88b85febcb45 811 @retval BLE_ERROR_NONE
iv123 0:88b85febcb45 812 Everything executed properly
iv123 0:88b85febcb45 813 */
iv123 0:88b85febcb45 814 /**************************************************************************/
iv123 0:88b85febcb45 815 ble_error_t BlueNRGGattClient::reset(void) {
iv123 0:88b85febcb45 816 /* Clear all state that is from the parent, including private members */
iv123 0:88b85febcb45 817 if (GattClient::reset() != BLE_ERROR_NONE) {
iv123 0:88b85febcb45 818 return BLE_ERROR_INVALID_STATE;
iv123 0:88b85febcb45 819 }
iv123 0:88b85febcb45 820
iv123 0:88b85febcb45 821 _currentState = GATT_IDLE;
iv123 0:88b85febcb45 822 _matchingServiceUUID = BLE_UUID_UNKNOWN;
iv123 0:88b85febcb45 823 _matchingCharacteristicUUIDIn = BLE_UUID_UNKNOWN;
iv123 0:88b85febcb45 824
iv123 0:88b85febcb45 825 _numServices = 0;
iv123 0:88b85febcb45 826 _servIndex = 0;
iv123 0:88b85febcb45 827 _numChars = 0;
iv123 0:88b85febcb45 828 _numCharDesc = 0;
iv123 0:88b85febcb45 829
iv123 0:88b85febcb45 830 /* Clear class members */
iv123 0:88b85febcb45 831 memset(discoveredService, 0, sizeof(discoveredService));
iv123 0:88b85febcb45 832 memset(discoveredChar, 0, sizeof(discoveredChar));
iv123 0:88b85febcb45 833
iv123 0:88b85febcb45 834 return BLE_ERROR_NONE;
iv123 0:88b85febcb45 835 }