Marco Zecchini
Rtos API example
Embed:
(wiki syntax)
Show/hide line numbers
GenericGattClient.cpp
00001 /* mbed Microcontroller Library 00002 * Copyright (c) 2017-2017 ARM Limited 00003 * 00004 * Licensed under the Apache License, Version 2.0 (the "License"); 00005 * you may not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an "AS IS" BASIS, 00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 00017 #include <stdio.h> 00018 #include <stdlib.h> 00019 00020 #include <ble/DiscoveredService.h> 00021 #include <ble/DiscoveredCharacteristic.h> 00022 #include "ble/generic/GenericGattClient.h" 00023 #include "ble/blecommon.h" 00024 #include <algorithm> 00025 00026 using ble::pal::AttServerMessage; 00027 using ble::pal::AttReadResponse; 00028 using ble::pal::AttReadBlobResponse; 00029 using ble::pal::AttReadByTypeResponse; 00030 using ble::pal::AttReadByGroupTypeResponse; 00031 using ble::pal::AttFindByTypeValueResponse; 00032 using ble::pal::AttErrorResponse; 00033 using ble::pal::AttributeOpcode; 00034 using ble::pal::AttWriteResponse; 00035 using ble::pal::AttPrepareWriteResponse; 00036 using ble::pal::AttExecuteWriteResponse; 00037 using ble::pal::AttHandleValueIndication; 00038 using ble::pal::AttHandleValueNotification; 00039 using ble::pal::AttFindInformationResponse; 00040 00041 namespace ble { 00042 namespace generic { 00043 00044 /* 00045 * Type of procedures which can be launched by the client. 00046 */ 00047 enum procedure_type_t { 00048 COMPLETE_DISCOVERY_PROCEDURE, 00049 READ_PROCEDURE, 00050 WRITE_PROCEDURE, 00051 DESCRIPTOR_DISCOVERY_PROCEDURE 00052 }; 00053 00054 00055 /* 00056 * Base class for a procedure control block 00057 */ 00058 struct procedure_control_block_t { 00059 /* 00060 * Base constructor for procedure control block. 00061 */ 00062 procedure_control_block_t(procedure_type_t type, Gap::Handle_t handle) : 00063 type(type), connection_handle(handle), next(NULL) { } 00064 00065 virtual ~procedure_control_block_t() { } 00066 00067 /* 00068 * Entry point of the control block stack machine. 00069 */ 00070 virtual void handle(GenericGattClient* client, const AttServerMessage& message) = 0; 00071 00072 /* 00073 * Function call in case of timeout 00074 */ 00075 virtual void handle_timeout_error(GenericGattClient* client) = 0; 00076 00077 procedure_type_t type; 00078 Gap::Handle_t connection_handle; 00079 procedure_control_block_t* next; 00080 }; 00081 00082 00083 /* 00084 * Procedure control block for the discovery process. 00085 */ 00086 struct discovery_control_block_t : public procedure_control_block_t { 00087 discovery_control_block_t( 00088 Gap::Handle_t handle, 00089 ServiceDiscovery::ServiceCallback_t service_callback, 00090 ServiceDiscovery::CharacteristicCallback_t characteristic_callback, 00091 UUID matching_service_uuid, 00092 UUID matching_characteristic_uuid 00093 ) : procedure_control_block_t(COMPLETE_DISCOVERY_PROCEDURE, handle), 00094 service_callback(service_callback), 00095 characteristic_callback(characteristic_callback), 00096 matching_service_uuid(matching_service_uuid), 00097 matching_characteristic_uuid(matching_characteristic_uuid), 00098 services_discovered(NULL), 00099 done(false) { 00100 } 00101 00102 virtual ~discovery_control_block_t() { 00103 while(services_discovered) { 00104 service_t* tmp = services_discovered->next; 00105 delete services_discovered; 00106 services_discovered = tmp; 00107 } 00108 } 00109 00110 virtual void handle_timeout_error(GenericGattClient* client) { 00111 terminate(client); 00112 } 00113 00114 virtual void handle(GenericGattClient* client, const AttServerMessage& message) { 00115 // if end of discovery has been requested, ends it immediately 00116 if (done) { 00117 terminate(client); 00118 return; 00119 } 00120 00121 switch(message.opcode) { 00122 case AttributeOpcode::READ_BY_GROUP_TYPE_RESPONSE: 00123 handle_service_discovered( 00124 client, static_cast<const AttReadByGroupTypeResponse&>(message) 00125 ); 00126 break; 00127 case AttributeOpcode::FIND_BY_VALUE_TYPE_RESPONSE: 00128 handle_service_discovered( 00129 client, static_cast<const AttFindByTypeValueResponse&>(message) 00130 ); 00131 break; 00132 case AttributeOpcode::READ_BY_TYPE_RESPONSE: 00133 handle_characteristic_discovered( 00134 client, static_cast<const AttReadByTypeResponse&>(message) 00135 ); 00136 break; 00137 case AttributeOpcode::ERROR_RESPONSE: { 00138 const AttErrorResponse& error = static_cast<const AttErrorResponse&>(message); 00139 if (error.error_code != AttErrorResponse::ATTRIBUTE_NOT_FOUND) { 00140 terminate(client); 00141 } 00142 00143 switch (error.request_opcode) { 00144 case AttributeOpcode::READ_BY_GROUP_TYPE_REQUEST: 00145 case AttributeOpcode::FIND_BY_TYPE_VALUE_REQUEST: 00146 start_characteristic_discovery(client); 00147 break; 00148 case AttributeOpcode::READ_BY_TYPE_REQUEST: 00149 handle_all_characteristics_discovered(client); 00150 break; 00151 default: 00152 // error 00153 break; 00154 } 00155 } break; 00156 default: 00157 // error 00158 break; 00159 } 00160 } 00161 00162 template<typename Response> 00163 void handle_service_discovered(GenericGattClient* client, const Response& response) { 00164 if (!response.size()) { 00165 terminate(client); 00166 return; 00167 } 00168 00169 uint16_t end_handle = 0x0000; 00170 for (size_t i = 0; i < response.size(); ++i) { 00171 uint16_t start_handle = get_start_handle(response[i]); 00172 end_handle = get_end_handle(response[i]); 00173 UUID uuid = get_uuid(response[i]); 00174 00175 if (!characteristic_callback) { 00176 DiscoveredService discovered_service; 00177 discovered_service.setup(uuid, start_handle, end_handle); 00178 service_callback(&discovered_service); 00179 } else { 00180 service_t* discovered_service = new (std::nothrow) service_t( 00181 start_handle, end_handle, uuid 00182 ); 00183 00184 if (discovered_service == NULL) { 00185 terminate(client); 00186 return; 00187 } 00188 00189 insert_service(discovered_service); 00190 } 00191 } 00192 00193 if (end_handle == 0xFFFF) { 00194 start_characteristic_discovery(client); 00195 } else { 00196 ble_error_t err = client->_pal_client->discover_primary_service( 00197 connection_handle, end_handle + 1 00198 ); 00199 00200 if (err) { 00201 terminate(client); 00202 } 00203 } 00204 } 00205 00206 void start_characteristic_discovery(GenericGattClient* client) { 00207 if (!services_discovered) { 00208 terminate(client); 00209 return; 00210 } 00211 00212 if (!characteristic_callback) { 00213 terminate(client); 00214 return; 00215 } 00216 00217 if (service_callback) { 00218 DiscoveredService discovered_service; 00219 discovered_service.setup( 00220 services_discovered->uuid, 00221 services_discovered->begin, 00222 services_discovered->end 00223 ); 00224 service_callback(&discovered_service); 00225 } 00226 00227 last_characteristic = characteristic_t(); 00228 client->_pal_client->discover_characteristics_of_a_service( 00229 connection_handle, 00230 attribute_handle_range( 00231 services_discovered->begin, 00232 services_discovered->end 00233 ) 00234 ); 00235 } 00236 00237 void handle_characteristic_discovered(GenericGattClient* client, const AttReadByTypeResponse& response) { 00238 for (size_t i = 0; i < response.size(); ++i) { 00239 if (last_characteristic.is_valid() == false) { 00240 last_characteristic.set_last_handle(response[i].handle - 1); 00241 if (matching_characteristic_uuid == UUID() 00242 || last_characteristic.getUUID() == matching_characteristic_uuid) { 00243 characteristic_callback(&last_characteristic); 00244 } 00245 } 00246 00247 last_characteristic = characteristic_t( 00248 client, connection_handle, response[i].handle, response[i].value 00249 ); 00250 } 00251 00252 // check if all the characteristics of the service has been discovered 00253 if (last_characteristic.getValueHandle() == services_discovered->end) { 00254 handle_all_characteristics_discovered(client); 00255 } else { 00256 ble_error_t err = client->_pal_client->discover_characteristics_of_a_service( 00257 connection_handle, 00258 attribute_handle_range( 00259 last_characteristic.getValueHandle() + 1, 00260 services_discovered->end 00261 ) 00262 ); 00263 00264 if (err) { 00265 terminate(client); 00266 } 00267 } 00268 } 00269 00270 void handle_all_characteristics_discovered(GenericGattClient* client) { 00271 if (last_characteristic.is_valid() == false) { 00272 if (matching_characteristic_uuid == UUID() 00273 || matching_characteristic_uuid == last_characteristic.getUUID()) { 00274 last_characteristic.set_last_handle(services_discovered->end); 00275 characteristic_callback(&last_characteristic); 00276 } 00277 } 00278 00279 service_t* old = services_discovered; 00280 services_discovered = services_discovered->next; 00281 delete old; 00282 00283 if (!services_discovered) { 00284 terminate(client); 00285 } else { 00286 start_characteristic_discovery(client); 00287 } 00288 } 00289 00290 void terminate(GenericGattClient* client) { 00291 // unknown error, terminate the procedure immediately 00292 client->remove_control_block(this); 00293 Gap::Handle_t handle = connection_handle; 00294 delete this; 00295 client->on_termination(handle); 00296 } 00297 00298 uint16_t get_start_handle(const AttReadByGroupTypeResponse::attribute_data_t& data) { 00299 return data.group_range.begin; 00300 } 00301 00302 uint16_t get_start_handle(const attribute_handle_range_t& range) { 00303 return range.begin; 00304 } 00305 00306 uint16_t get_end_handle(const AttReadByGroupTypeResponse::attribute_data_t& data) { 00307 return data.group_range.end; 00308 } 00309 00310 uint16_t get_end_handle(const attribute_handle_range_t& range) { 00311 return range.end; 00312 } 00313 00314 UUID get_uuid(const AttReadByGroupTypeResponse::attribute_data_t& data) { 00315 if (data.value.size() == 2) { 00316 return UUID(data.value[0] | data.value[1] << 8); 00317 } else { 00318 return UUID(data.value.data(), UUID::LSB); 00319 } 00320 } 00321 00322 UUID get_uuid(const attribute_handle_range_t& range) { 00323 return matching_service_uuid; 00324 } 00325 00326 struct service_t { 00327 service_t(uint16_t begin, uint16_t end, const UUID& uuid) : 00328 begin(begin), end(end), uuid(uuid), next(NULL) { } 00329 uint16_t begin; 00330 uint16_t end; 00331 UUID uuid; 00332 service_t* next; 00333 }; 00334 00335 struct characteristic_t : DiscoveredCharacteristic { 00336 characteristic_t() : DiscoveredCharacteristic() { 00337 lastHandle = 0x0001; 00338 } 00339 00340 characteristic_t( 00341 GattClient* client, 00342 Gap::Handle_t connection_handle, 00343 uint16_t decl_handle, 00344 const ArrayView<const uint8_t> value 00345 ) : DiscoveredCharacteristic() { 00346 gattc = client; 00347 uuid = get_uuid(value); 00348 props = get_properties(value); 00349 declHandle = decl_handle; 00350 valueHandle = get_value_handle(value); 00351 lastHandle = 0x0000; 00352 connHandle = connection_handle; 00353 } 00354 00355 static UUID get_uuid(const ArrayView<const uint8_t>& value) { 00356 if (value.size() == 5) { 00357 return UUID(value[3] | (value[4] << 8)); 00358 } else { 00359 return UUID(value.data() + 3, UUID::LSB); 00360 } 00361 } 00362 00363 static DiscoveredCharacteristic::Properties_t get_properties(const ArrayView<const uint8_t>& value) { 00364 uint8_t raw_properties = value[0]; 00365 DiscoveredCharacteristic::Properties_t result; 00366 result._broadcast = (raw_properties & (1 << 0)) ? true : false; 00367 result._read = (raw_properties & (1 << 1)) ? true : false; 00368 result._writeWoResp = (raw_properties & (1 << 2)) ? true : false; 00369 result._write = (raw_properties & (1 << 3)) ? true : false; 00370 result._notify = (raw_properties & (1 << 4)) ? true : false; 00371 result._indicate = (raw_properties & (1 << 5)) ? true : false; 00372 result._authSignedWrite = (raw_properties & (1 << 6)) ? true : false; 00373 return result; 00374 } 00375 00376 static uint16_t get_value_handle(const ArrayView<const uint8_t>& value) { 00377 return value[1] | (value[2] << 8); 00378 } 00379 00380 void set_last_handle(uint16_t last_handle) { 00381 lastHandle = last_handle; 00382 } 00383 00384 bool is_valid() const { 00385 return lastHandle != 0x0000; 00386 } 00387 }; 00388 00389 void insert_service(service_t* service) { 00390 if (services_discovered == NULL) { 00391 services_discovered = service; 00392 return; 00393 } 00394 00395 service_t* current = services_discovered; 00396 while (current->next) { 00397 current = current->next; 00398 } 00399 current->next = service; 00400 } 00401 00402 ServiceDiscovery::ServiceCallback_t service_callback; 00403 ServiceDiscovery::CharacteristicCallback_t characteristic_callback; 00404 UUID matching_service_uuid; 00405 UUID matching_characteristic_uuid; 00406 service_t* services_discovered; 00407 characteristic_t last_characteristic; 00408 bool done; 00409 }; 00410 00411 00412 struct read_control_block_t : public procedure_control_block_t { 00413 read_control_block_t( 00414 Gap::Handle_t connection_handle, uint16_t attribute_handle, uint16_t offset 00415 ) : procedure_control_block_t(READ_PROCEDURE, connection_handle), 00416 attribute_handle(attribute_handle), 00417 offset(offset), current_offset(offset), data(NULL) { 00418 } 00419 00420 virtual ~read_control_block_t() { 00421 if (data != NULL) { 00422 free(data); 00423 } 00424 } 00425 00426 virtual void handle_timeout_error(GenericGattClient* client) { 00427 GattReadCallbackParams response = { 00428 connection_handle, 00429 attribute_handle, 00430 offset, 00431 0, // size of 0 00432 NULL, // no data 00433 BLE_ERROR_UNSPECIFIED, 00434 00435 }; 00436 terminate(client, response); 00437 } 00438 00439 void terminate(GenericGattClient* client, const GattReadCallbackParams& response) { 00440 client->remove_control_block(this); 00441 client->processReadResponse(&response); 00442 delete this; 00443 } 00444 00445 virtual void handle(GenericGattClient* client, const AttServerMessage& message) { 00446 switch(message.opcode) { 00447 case AttributeOpcode::ERROR_RESPONSE: 00448 handle_error(client, static_cast<const AttErrorResponse&>(message)); 00449 break; 00450 00451 case AttributeOpcode::READ_RESPONSE: 00452 handle_read_response(client, static_cast<const AttReadResponse&>(message)); 00453 break; 00454 00455 case AttributeOpcode::READ_BLOB_RESPONSE: 00456 handle_read_response(client, static_cast<const AttReadBlobResponse&>(message)); 00457 break; 00458 00459 default: { 00460 // should not happen, terminate the procedure and notify client with an error 00461 // in such case 00462 GattReadCallbackParams response = { 00463 connection_handle, 00464 attribute_handle, 00465 AttErrorResponse::UNLIKELY_ERROR, 00466 0, // size of 0 00467 NULL, // no data 00468 BLE_ERROR_UNSPECIFIED, 00469 00470 }; 00471 terminate(client, response); 00472 } break; 00473 } 00474 } 00475 00476 template<typename ResponseType> 00477 void handle_read_response(GenericGattClient* client, const ResponseType& read_response) { 00478 uint16_t mtu_size = client->get_mtu(connection_handle); 00479 00480 // end of responses ? 00481 if ((uint16_t) read_response.size() < (mtu_size - 1)) { 00482 GattReadCallbackParams response = { 00483 connection_handle, 00484 attribute_handle, 00485 offset, 00486 0, // size of 0 00487 NULL, // no data 00488 BLE_ERROR_NONE, 00489 }; 00490 00491 // is it the first response, or is there any other response already 00492 // in the object ? 00493 if (data == NULL) { 00494 response.len = (uint16_t) read_response.size(); 00495 response.data = read_response.data(); 00496 } else { 00497 // copy the data in the existing buffer 00498 memcpy(data + (current_offset - offset), read_response.data(), read_response.size()); 00499 response.len = (current_offset + read_response.size()) - offset; 00500 response.data = data; 00501 } 00502 terminate(client, response); 00503 } else { 00504 // allocation which will contain the response data plus the next one. 00505 data = (uint8_t*) realloc(data, (current_offset - offset) + ((mtu_size - 1) * 2)); 00506 if (data == NULL) { 00507 GattReadCallbackParams response = { 00508 connection_handle, 00509 attribute_handle, 00510 offset, 00511 AttErrorResponse::INSUFFICIENT_RESOURCES, 00512 NULL, 00513 BLE_ERROR_NO_MEM, 00514 }; 00515 terminate(client, response); 00516 return; 00517 } 00518 00519 memcpy(data + (current_offset - offset), read_response.data(), read_response.size()); 00520 current_offset = current_offset + read_response.size(); 00521 ble_error_t err = client->_pal_client->read_attribute_blob( 00522 connection_handle, 00523 attribute_handle, 00524 current_offset 00525 ); 00526 00527 if (err) { 00528 GattReadCallbackParams response = { 00529 connection_handle, 00530 attribute_handle, 00531 AttErrorResponse::UNLIKELY_ERROR, 00532 0, // size of 0 00533 NULL, // no data 00534 BLE_ERROR_UNSPECIFIED, 00535 00536 }; 00537 terminate(client, response); 00538 } 00539 } 00540 } 00541 00542 void handle_error(GenericGattClient* client, const AttErrorResponse& error) { 00543 ble_error_t status = BLE_ERROR_UNSPECIFIED; 00544 00545 switch (error.error_code) { 00546 case AttErrorResponse::INVALID_HANDLE: 00547 status = BLE_ERROR_INVALID_PARAM; 00548 break; 00549 case AttErrorResponse::INSUFFICIENT_AUTHORIZATION: 00550 status = BLE_ERROR_INVALID_STATE; 00551 break; 00552 case AttErrorResponse::INSUFFICIENT_AUTHENTICATION: 00553 status = BLE_ERROR_INVALID_STATE; 00554 break; 00555 case AttErrorResponse::INSUFFICIENT_ENCRYPTION_KEY_SIZE: 00556 status = BLE_ERROR_INVALID_STATE; 00557 break; 00558 case AttErrorResponse::INSUFFICIENT_ENCRYPTION: 00559 status = BLE_ERROR_INVALID_STATE; 00560 break; 00561 case AttErrorResponse::READ_NOT_PERMITTED: 00562 status = BLE_ERROR_OPERATION_NOT_PERMITTED; 00563 break; 00564 case AttErrorResponse::INVALID_OFFSET: 00565 status = BLE_ERROR_PARAM_OUT_OF_RANGE; 00566 break; 00567 case AttErrorResponse::ATTRIBUTE_NOT_LONG: 00568 status = BLE_ERROR_PARAM_OUT_OF_RANGE; 00569 break; 00570 default: 00571 status = BLE_ERROR_UNSPECIFIED; 00572 break; 00573 } 00574 00575 GattReadCallbackParams response = { 00576 connection_handle, 00577 attribute_handle, 00578 offset, 00579 error.error_code, 00580 /* data */ NULL, 00581 status 00582 }; 00583 00584 terminate(client, response); 00585 } 00586 00587 uint16_t attribute_handle; 00588 uint16_t offset; 00589 uint16_t current_offset; 00590 uint8_t* data; 00591 }; 00592 00593 /* 00594 * Control block for the write process 00595 */ 00596 struct write_control_block_t : public procedure_control_block_t { 00597 write_control_block_t( 00598 Gap::Handle_t connection_handle, uint16_t attribute_handle, 00599 uint8_t* data, uint16_t len 00600 ) : procedure_control_block_t(WRITE_PROCEDURE, connection_handle), 00601 attribute_handle(attribute_handle), len(len), offset(0), data(data), 00602 prepare_success(false), status(BLE_ERROR_UNSPECIFIED), error_code(0xFF) { 00603 } 00604 00605 virtual ~write_control_block_t() { 00606 free(data); 00607 } 00608 00609 virtual void handle_timeout_error(GenericGattClient* client) { 00610 GattWriteCallbackParams response = { 00611 connection_handle, 00612 attribute_handle, 00613 GattWriteCallbackParams::OP_WRITE_REQ, 00614 BLE_ERROR_UNSPECIFIED, 00615 0x00 00616 }; 00617 terminate(client, response); 00618 } 00619 00620 void terminate(GenericGattClient* client, const GattWriteCallbackParams& response) { 00621 client->remove_control_block(this); 00622 client->processWriteResponse(&response); 00623 delete this; 00624 } 00625 00626 virtual void handle(GenericGattClient* client, const AttServerMessage& message) { 00627 switch(message.opcode) { 00628 case AttributeOpcode::ERROR_RESPONSE: 00629 handle_error(client, static_cast<const AttErrorResponse&>(message)); 00630 break; 00631 00632 case AttributeOpcode::WRITE_RESPONSE: 00633 handle_write_response(client, static_cast<const AttWriteResponse&>(message)); 00634 break; 00635 00636 case AttributeOpcode::PREPARE_WRITE_RESPONSE: 00637 handle_prepare_write_response(client, static_cast<const AttPrepareWriteResponse&>(message)); 00638 break; 00639 00640 case AttributeOpcode::EXECUTE_WRITE_RESPONSE: 00641 handle_execute_write_response(client, static_cast<const AttExecuteWriteResponse&>(message)); 00642 break; 00643 00644 default: { 00645 GattWriteCallbackParams response = { 00646 connection_handle, 00647 attribute_handle, 00648 GattWriteCallbackParams::OP_WRITE_REQ, 00649 BLE_ERROR_UNSPECIFIED, 00650 AttErrorResponse::UNLIKELY_ERROR 00651 }; 00652 00653 terminate(client, response); 00654 } break; 00655 } 00656 } 00657 00658 void handle_write_response(GenericGattClient* client, const AttWriteResponse& write_response) { 00659 GattWriteCallbackParams response = { 00660 connection_handle, attribute_handle, 00661 GattWriteCallbackParams::OP_WRITE_REQ, 00662 BLE_ERROR_NONE, 0x00 00663 }; 00664 00665 terminate(client, response); 00666 } 00667 00668 void handle_prepare_write_response(GenericGattClient* client, const AttPrepareWriteResponse& write_response) { 00669 ble_error_t err = BLE_ERROR_UNSPECIFIED; 00670 00671 uint16_t mtu_size = client->get_mtu(connection_handle); 00672 offset = write_response.offset + write_response.partial_value.size(); 00673 if (offset < len) { 00674 err = client->_pal_client->queue_prepare_write( 00675 connection_handle, attribute_handle, 00676 make_const_ArrayView( 00677 data + offset, 00678 std::min((len - offset), (mtu_size - 5)) 00679 ), 00680 offset 00681 ); 00682 } else { 00683 err = client->_pal_client->execute_write_queue( 00684 connection_handle, true 00685 ); 00686 } 00687 00688 if (err) { 00689 clear_prepare_queue(client, err, AttErrorResponse::UNLIKELY_ERROR); 00690 } 00691 } 00692 00693 void handle_execute_write_response(GenericGattClient* client, const AttExecuteWriteResponse& execute_response) { 00694 if (prepare_success) { 00695 status = BLE_ERROR_NONE; 00696 error_code = 0x00; 00697 } 00698 00699 GattWriteCallbackParams response = { 00700 connection_handle, 00701 attribute_handle, 00702 GattWriteCallbackParams::OP_WRITE_REQ, 00703 status, 00704 error_code 00705 }; 00706 00707 terminate(client, response); 00708 } 00709 00710 void clear_prepare_queue(GenericGattClient* client, ble_error_t s, uint8_t e) { 00711 prepare_success = false; 00712 status = s; 00713 error_code = e; 00714 ble_error_t err = client->_pal_client->execute_write_queue( 00715 connection_handle, false 00716 ); 00717 00718 if (err) { 00719 GattWriteCallbackParams response = { 00720 connection_handle, 00721 attribute_handle, 00722 GattWriteCallbackParams::OP_WRITE_REQ, 00723 err, 00724 AttErrorResponse::UNLIKELY_ERROR 00725 }; 00726 00727 terminate(client, response); 00728 } 00729 } 00730 00731 void handle_error(GenericGattClient* client, const AttErrorResponse& error) { 00732 ble_error_t status = BLE_ERROR_UNSPECIFIED; 00733 00734 switch (error.error_code) { 00735 case AttErrorResponse::INVALID_HANDLE: 00736 status = BLE_ERROR_INVALID_PARAM; 00737 break; 00738 case AttErrorResponse::INVALID_ATTRIBUTE_VALUE_LENGTH: 00739 status = BLE_ERROR_INVALID_PARAM; 00740 break; 00741 case AttErrorResponse::INSUFFICIENT_AUTHORIZATION: 00742 status = BLE_ERROR_INVALID_STATE; 00743 break; 00744 case AttErrorResponse::INSUFFICIENT_AUTHENTICATION: 00745 status = BLE_ERROR_INVALID_STATE; 00746 break; 00747 case AttErrorResponse::INSUFFICIENT_ENCRYPTION_KEY_SIZE: 00748 status = BLE_ERROR_INVALID_STATE; 00749 break; 00750 case AttErrorResponse::INSUFFICIENT_ENCRYPTION: 00751 status = BLE_ERROR_INVALID_STATE; 00752 break; 00753 case AttErrorResponse::WRITE_NOT_PERMITTED: 00754 status = BLE_ERROR_OPERATION_NOT_PERMITTED; 00755 break; 00756 default: 00757 status = BLE_ERROR_UNSPECIFIED; 00758 break; 00759 } 00760 00761 if (error.request_opcode == AttributeOpcode(AttributeOpcode::PREPARE_WRITE_REQUEST)) { 00762 clear_prepare_queue(client, status, error.error_code); 00763 } else { 00764 GattWriteCallbackParams response = { 00765 connection_handle, 00766 attribute_handle, 00767 GattWriteCallbackParams::OP_WRITE_REQ, 00768 status, 00769 error.error_code 00770 }; 00771 00772 terminate(client, response); 00773 } 00774 } 00775 00776 uint16_t attribute_handle; 00777 uint16_t len; 00778 uint16_t offset; 00779 uint8_t* data; 00780 bool prepare_success; 00781 ble_error_t status; 00782 uint8_t error_code; 00783 }; 00784 00785 /* 00786 * Control block for the descriptor discovery process 00787 */ 00788 struct descriptor_discovery_control_block_t : public procedure_control_block_t { 00789 descriptor_discovery_control_block_t( 00790 const DiscoveredCharacteristic& characteristic, 00791 const CharacteristicDescriptorDiscovery::DiscoveryCallback_t & discoveryCallback, 00792 const CharacteristicDescriptorDiscovery::TerminationCallback_t & terminationCallback 00793 ) : procedure_control_block_t(DESCRIPTOR_DISCOVERY_PROCEDURE, characteristic.getConnectionHandle()), 00794 characteristic(characteristic), 00795 discovery_cb(discoveryCallback), 00796 termination_cb(terminationCallback), 00797 next_handle(characteristic.getValueHandle() + 1), 00798 done(false) { 00799 } 00800 00801 virtual ~descriptor_discovery_control_block_t() { } 00802 00803 ble_error_t start(GenericGattClient* client) { 00804 return client->_pal_client->discover_characteristics_descriptors( 00805 connection_handle, 00806 attribute_handle_range( 00807 next_handle, 00808 characteristic.getLastHandle() 00809 ) 00810 ); 00811 } 00812 00813 virtual void handle_timeout_error(GenericGattClient* client) { 00814 terminate(client, BLE_ERROR_UNSPECIFIED); 00815 } 00816 00817 virtual void handle(GenericGattClient* client, const AttServerMessage& message) { 00818 if (done) { 00819 terminate(client, BLE_ERROR_NONE); 00820 return; 00821 } 00822 00823 switch(message.opcode) { 00824 case AttributeOpcode::ERROR_RESPONSE: 00825 handle_error(client, static_cast<const AttErrorResponse&>(message)); 00826 return; 00827 00828 case AttributeOpcode::FIND_INFORMATION_RESPONSE: 00829 handle_response(client, static_cast<const AttFindInformationResponse&>(message)); 00830 return; 00831 00832 default: 00833 break; 00834 } 00835 } 00836 00837 void handle_error(GenericGattClient* client, const AttErrorResponse& error) { 00838 if (error.error_code == AttErrorResponse::ATTRIBUTE_NOT_FOUND) { 00839 terminate(client, BLE_ERROR_NONE); 00840 } else { 00841 terminate(client, BLE_ERROR_UNSPECIFIED, error.error_code); 00842 } 00843 } 00844 00845 void handle_response(GenericGattClient* client, const AttFindInformationResponse& response) { 00846 for (size_t i = 0; i < response.size(); ++i) { 00847 DiscoveredCharacteristicDescriptor descriptor( 00848 client, connection_handle, response[i].handle, response[i].uuid 00849 ); 00850 CharacteristicDescriptorDiscovery::DiscoveryCallbackParams_t params = { 00851 characteristic, 00852 descriptor 00853 }; 00854 discovery_cb(¶ms); 00855 if (done) { 00856 terminate(client, BLE_ERROR_NONE); 00857 return; 00858 } 00859 00860 if (response[i].handle == characteristic.getLastHandle()) { 00861 terminate(client, BLE_ERROR_NONE); 00862 return; 00863 } 00864 next_handle = response[i].handle + 1; 00865 } 00866 00867 ble_error_t err = start(client); 00868 if (err) { 00869 terminate(client, err, AttErrorResponse::UNLIKELY_ERROR); 00870 } 00871 } 00872 00873 void terminate(GenericGattClient* client, ble_error_t status, uint8_t error_code = 0x00) { 00874 client->remove_control_block(this); 00875 CharacteristicDescriptorDiscovery::TerminationCallbackParams_t params = { 00876 characteristic, 00877 status, 00878 error_code 00879 }; 00880 termination_cb(¶ms); 00881 delete this; 00882 } 00883 00884 DiscoveredCharacteristic characteristic; 00885 CharacteristicDescriptorDiscovery::DiscoveryCallback_t discovery_cb; 00886 CharacteristicDescriptorDiscovery::TerminationCallback_t termination_cb; 00887 uint16_t next_handle; 00888 bool done; 00889 }; 00890 00891 00892 GenericGattClient::GenericGattClient(pal::GattClient* pal_client) : 00893 _pal_client(pal_client), 00894 _termination_callback(), 00895 control_blocks(NULL) { 00896 _pal_client->when_server_message_received( 00897 mbed::callback(this, &GenericGattClient::on_server_message_received) 00898 ); 00899 _pal_client->when_transaction_timeout( 00900 mbed::callback(this, &GenericGattClient::on_transaction_timeout) 00901 ); 00902 } 00903 00904 ble_error_t GenericGattClient::launchServiceDiscovery ( 00905 Gap::Handle_t connection_handle, 00906 ServiceDiscovery::ServiceCallback_t service_callback, 00907 ServiceDiscovery::CharacteristicCallback_t characteristic_callback, 00908 const UUID& matching_service_uuid, 00909 const UUID& matching_characteristic_uuid 00910 ) { 00911 // verify that there is no other procedures going on this connection 00912 if (get_control_block(connection_handle)) { 00913 return BLE_ERROR_INVALID_STATE; 00914 } 00915 00916 // terminate and return if there is no callback to call 00917 if (!service_callback && !characteristic_callback) { 00918 on_termination(connection_handle); 00919 return BLE_ERROR_NONE; 00920 } 00921 00922 discovery_control_block_t* discovery_pcb = new(std::nothrow) discovery_control_block_t( 00923 connection_handle, 00924 service_callback, 00925 characteristic_callback, 00926 matching_service_uuid, 00927 matching_characteristic_uuid 00928 ); 00929 00930 if (discovery_pcb == NULL) { 00931 return BLE_ERROR_NO_MEM; 00932 } 00933 00934 // note: control block inserted prior the request because they are part of 00935 // of the transaction and the callback can be call synchronously 00936 insert_control_block(discovery_pcb); 00937 00938 // launch the request 00939 ble_error_t err = BLE_ERROR_UNSPECIFIED; 00940 if (matching_service_uuid == UUID()) { 00941 err = _pal_client->discover_primary_service( 00942 connection_handle, 00943 0x0001 00944 ); 00945 } else { 00946 err = _pal_client->discover_primary_service_by_service_uuid( 00947 connection_handle, 00948 0x0001, 00949 matching_service_uuid 00950 ); 00951 } 00952 00953 if (err) { 00954 remove_control_block(discovery_pcb); 00955 delete discovery_pcb; 00956 } 00957 00958 return err; 00959 } 00960 00961 bool GenericGattClient::isServiceDiscoveryActive () const { 00962 procedure_control_block_t* pcb = control_blocks; 00963 00964 while (pcb) { 00965 if (pcb->type == COMPLETE_DISCOVERY_PROCEDURE) { 00966 return true; 00967 } 00968 pcb = pcb->next; 00969 } 00970 00971 return false; 00972 } 00973 00974 void GenericGattClient::terminateServiceDiscovery () 00975 { 00976 procedure_control_block_t* pcb = control_blocks; 00977 while (pcb) { 00978 if (pcb->type == COMPLETE_DISCOVERY_PROCEDURE) { 00979 static_cast<discovery_control_block_t*>(pcb)->done = true; 00980 } 00981 pcb = pcb->next; 00982 } 00983 } 00984 00985 ble_error_t GenericGattClient::read ( 00986 Gap::Handle_t connection_handle, 00987 GattAttribute::Handle_t attribute_handle, 00988 uint16_t offset) const 00989 { 00990 // verify that there is no other procedures going on this connection 00991 if (get_control_block(connection_handle)) { 00992 return BLE_ERROR_INVALID_STATE; 00993 } 00994 00995 read_control_block_t* read_pcb = new(std::nothrow) read_control_block_t( 00996 connection_handle, 00997 attribute_handle, 00998 offset 00999 ); 01000 01001 if (read_pcb == NULL) { 01002 return BLE_ERROR_NO_MEM; 01003 } 01004 01005 insert_control_block(read_pcb); 01006 01007 ble_error_t err = BLE_ERROR_NONE; 01008 01009 if (offset == 0) { 01010 err = _pal_client->read_attribute_value( 01011 connection_handle, attribute_handle 01012 ); 01013 } else { 01014 err = _pal_client->read_attribute_blob( 01015 connection_handle, attribute_handle, offset 01016 ); 01017 } 01018 01019 if (err) { 01020 remove_control_block(read_pcb); 01021 delete read_pcb; 01022 } 01023 01024 return err; 01025 } 01026 01027 ble_error_t GenericGattClient::write ( 01028 GattClient::WriteOp_t cmd, 01029 Gap::Handle_t connection_handle, 01030 GattAttribute::Handle_t attribute_handle, 01031 size_t length, 01032 const uint8_t* value 01033 ) const { 01034 // verify that there is no other procedures going on this connection 01035 if (get_control_block(connection_handle)) { 01036 return BLE_ERROR_INVALID_STATE; 01037 } 01038 01039 uint16_t mtu = get_mtu(connection_handle); 01040 01041 if (cmd == GattClient::GATT_OP_WRITE_CMD) { 01042 if (length > (uint16_t)(mtu - 3)) { 01043 return BLE_ERROR_PARAM_OUT_OF_RANGE; 01044 } 01045 return _pal_client->write_without_response( 01046 connection_handle, 01047 attribute_handle, 01048 make_const_ArrayView(value, length) 01049 ); 01050 } else { 01051 uint8_t* data = NULL; 01052 01053 if (length > (uint16_t)(mtu - 3)) { 01054 data = (uint8_t*) malloc(length); 01055 if (data == NULL) { 01056 return BLE_ERROR_NO_MEM; 01057 } 01058 memcpy(data, value, length); 01059 } 01060 01061 write_control_block_t* write_pcb = new(std::nothrow) write_control_block_t( 01062 connection_handle, 01063 attribute_handle, 01064 data, 01065 length 01066 ); 01067 01068 if (write_pcb == NULL) { 01069 free(data); 01070 return BLE_ERROR_NO_MEM; 01071 } 01072 01073 insert_control_block(write_pcb); 01074 01075 ble_error_t err = BLE_ERROR_UNSPECIFIED; 01076 if (data) { 01077 err = _pal_client->queue_prepare_write( 01078 connection_handle, 01079 attribute_handle, 01080 make_const_ArrayView(value, mtu - 5), 01081 /* offset */ 0 01082 ); 01083 } else { 01084 err = _pal_client->write_attribute( 01085 connection_handle, 01086 attribute_handle, 01087 make_const_ArrayView(value, length) 01088 ); 01089 } 01090 01091 if (err) { 01092 remove_control_block(write_pcb); 01093 delete write_pcb; 01094 } 01095 01096 return err; 01097 } 01098 01099 return BLE_ERROR_NOT_IMPLEMENTED; 01100 } 01101 01102 void GenericGattClient::onServiceDiscoveryTermination ( 01103 ServiceDiscovery::TerminationCallback_t callback 01104 ) { 01105 _termination_callback = callback; 01106 } 01107 01108 ble_error_t GenericGattClient::discoverCharacteristicDescriptors ( 01109 const DiscoveredCharacteristic& characteristic, 01110 const CharacteristicDescriptorDiscovery::DiscoveryCallback_t & discoveryCallback, 01111 const CharacteristicDescriptorDiscovery::TerminationCallback_t & terminationCallback 01112 ) { 01113 // verify that there is no other procedures going on this connection 01114 if (get_control_block(characteristic.getConnectionHandle())) { 01115 return BLE_ERROR_INVALID_STATE; 01116 } 01117 01118 if (characteristic.getValueHandle() == characteristic.getLastHandle()) { 01119 CharacteristicDescriptorDiscovery::TerminationCallbackParams_t params = { 01120 characteristic, 01121 BLE_ERROR_NONE, 01122 /* error code */ 0x00 01123 }; 01124 01125 terminationCallback(¶ms); 01126 return BLE_ERROR_NONE; 01127 } 01128 01129 descriptor_discovery_control_block_t* discovery_pcb = 01130 new(std::nothrow) descriptor_discovery_control_block_t( 01131 characteristic, 01132 discoveryCallback, 01133 terminationCallback 01134 ); 01135 01136 if (discovery_pcb == NULL) { 01137 return BLE_ERROR_NO_MEM; 01138 } 01139 01140 insert_control_block(discovery_pcb); 01141 01142 ble_error_t err = discovery_pcb->start(this); 01143 01144 if (err) { 01145 remove_control_block(discovery_pcb); 01146 delete discovery_pcb; 01147 } 01148 01149 return err; 01150 } 01151 01152 bool GenericGattClient::isCharacteristicDescriptorDiscoveryActive ( 01153 const DiscoveredCharacteristic& characteristic 01154 ) const { 01155 procedure_control_block_t* pcb = control_blocks; 01156 01157 while (pcb) { 01158 if (pcb->type == DESCRIPTOR_DISCOVERY_PROCEDURE && 01159 static_cast<descriptor_discovery_control_block_t*>(pcb)->characteristic == characteristic) { 01160 return true; 01161 } 01162 pcb = pcb->next; 01163 } 01164 01165 return false; 01166 } 01167 01168 void GenericGattClient::terminateCharacteristicDescriptorDiscovery ( 01169 const DiscoveredCharacteristic& characteristic 01170 ) { 01171 procedure_control_block_t* pcb = control_blocks; 01172 01173 while (pcb) { 01174 if (pcb->type == DESCRIPTOR_DISCOVERY_PROCEDURE) { 01175 descriptor_discovery_control_block_t* dpcb = 01176 static_cast<descriptor_discovery_control_block_t*>(pcb); 01177 if (dpcb->characteristic == characteristic) { 01178 dpcb->done = true; 01179 return; 01180 } 01181 } 01182 01183 pcb = pcb->next; 01184 } 01185 01186 } 01187 01188 ble_error_t GenericGattClient::reset (void) { 01189 return BLE_ERROR_NOT_IMPLEMENTED; 01190 } 01191 01192 void GenericGattClient::on_termination(Gap::Handle_t connection_handle) { 01193 if (_termination_callback) { 01194 _termination_callback(connection_handle); 01195 } 01196 } 01197 01198 void GenericGattClient::on_server_message_received( 01199 connection_handle_t connection_handle, 01200 const AttServerMessage& message 01201 ) { 01202 switch(message.opcode) { 01203 case AttributeOpcode::ERROR_RESPONSE: 01204 case AttributeOpcode::EXCHANGE_MTU_RESPONSE: 01205 case AttributeOpcode::FIND_INFORMATION_RESPONSE: 01206 case AttributeOpcode::FIND_BY_VALUE_TYPE_RESPONSE: 01207 case AttributeOpcode::READ_BY_TYPE_RESPONSE: 01208 case AttributeOpcode::READ_RESPONSE: 01209 case AttributeOpcode::READ_BLOB_RESPONSE: 01210 case AttributeOpcode::READ_MULTIPLE_RESPONSE: 01211 case AttributeOpcode::READ_BY_GROUP_TYPE_RESPONSE: 01212 case AttributeOpcode::WRITE_RESPONSE: 01213 case AttributeOpcode::PREPARE_WRITE_RESPONSE: 01214 case AttributeOpcode::EXECUTE_WRITE_RESPONSE: { 01215 on_server_response(connection_handle, message); 01216 } break; 01217 01218 case AttributeOpcode::HANDLE_VALUE_INDICATION: 01219 case AttributeOpcode::HANDLE_VALUE_NOTIFICATION: { 01220 on_server_event(connection_handle, message); 01221 } break; 01222 01223 default: 01224 // invalid message receive 01225 return; 01226 } 01227 } 01228 01229 void GenericGattClient::on_server_response( 01230 connection_handle_t connection, 01231 const AttServerMessage& message 01232 ) { 01233 procedure_control_block_t* pcb = get_control_block(connection); 01234 if (pcb == NULL) { 01235 return; 01236 } 01237 01238 pcb->handle(this, message); 01239 } 01240 01241 void GenericGattClient::on_server_event(connection_handle_t connection, const AttServerMessage& message) { 01242 GattHVXCallbackParams callbacks_params = { 01243 (Gap::Handle_t) connection, 0 01244 }; 01245 01246 switch (message.opcode) { 01247 case AttributeOpcode::HANDLE_VALUE_NOTIFICATION: { 01248 const AttHandleValueNotification& notification = 01249 static_cast<const AttHandleValueNotification&>(message); 01250 callbacks_params.handle = notification.attribute_handle; 01251 callbacks_params.type = BLE_HVX_NOTIFICATION; 01252 callbacks_params.len = notification.attribute_value.size(); 01253 callbacks_params.data = notification.attribute_value.data(); 01254 } break; 01255 01256 case AttributeOpcode::HANDLE_VALUE_INDICATION: { 01257 const AttHandleValueIndication& indication = 01258 static_cast<const AttHandleValueIndication&>(message); 01259 callbacks_params.handle = indication.attribute_handle; 01260 callbacks_params.type = BLE_HVX_INDICATION; 01261 callbacks_params.len = indication.attribute_value.size(); 01262 callbacks_params.data = indication.attribute_value.data(); 01263 } break; 01264 01265 default: 01266 return; 01267 } 01268 01269 processHVXEvent(&callbacks_params); 01270 } 01271 01272 void GenericGattClient::on_transaction_timeout(connection_handle_t connection) { 01273 procedure_control_block_t* pcb = get_control_block(connection); 01274 if (pcb == NULL) { 01275 return; 01276 } 01277 01278 pcb->handle_timeout_error(this); 01279 } 01280 01281 procedure_control_block_t* GenericGattClient::get_control_block(Gap::Handle_t connection) { 01282 procedure_control_block_t* it = control_blocks; 01283 while (it && it->connection_handle != connection) { 01284 it = it->next; 01285 } 01286 return it; 01287 } 01288 01289 const procedure_control_block_t* GenericGattClient::get_control_block(Gap::Handle_t connection) const { 01290 procedure_control_block_t* it = control_blocks; 01291 while (it && it->connection_handle != connection) { 01292 it = it->next; 01293 } 01294 return it; 01295 } 01296 01297 void GenericGattClient::insert_control_block(procedure_control_block_t* cb) const { 01298 if (control_blocks == NULL) { 01299 control_blocks = cb; 01300 return; 01301 } 01302 01303 procedure_control_block_t* current = control_blocks; 01304 while (current->next) { 01305 current = current->next; 01306 } 01307 current->next = cb; 01308 } 01309 01310 void GenericGattClient::remove_control_block(procedure_control_block_t* cb) const { 01311 if (control_blocks == NULL) { 01312 return; 01313 } 01314 01315 if (cb == control_blocks) { 01316 control_blocks = control_blocks->next; 01317 return; 01318 } 01319 01320 procedure_control_block_t* current = control_blocks; 01321 while (current->next && current->next != cb) { 01322 current = current->next; 01323 } 01324 01325 if (current->next == NULL) { 01326 return; 01327 } 01328 01329 current->next = cb->next; 01330 cb->next = NULL; 01331 } 01332 01333 uint16_t GenericGattClient::get_mtu(Gap::Handle_t connection) const { 01334 uint16_t result = 23; 01335 if(_pal_client->get_mtu_size((connection_handle_t) connection, result) != BLE_ERROR_NONE) { 01336 result = 23; 01337 } 01338 return result; 01339 } 01340 01341 } // namespace pal 01342 } // namespace ble
Generated on Sun Jul 17 2022 08:25:23 by
1.7.2