mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-02-09 12:39:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

ble client: rename gatt client state

Browse Source
This commit is contained in:
mila@ringwald.ch 2014-04-25 14:31:04 +00:00
parent 97f577dd92
commit c04594a5c5
2 changed files with 92 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

182
example/libusb/ble_client.c
View File

@ -444,109 +444,109 @@ static void gatt_client_handle_peripheral_list(){
return; return;
} }
switch (peripheral->state){ switch (peripheral->gatt_client_state){
case P_W2_SEND_SERVICE_QUERY: case P_W2_SEND_SERVICE_QUERY:
peripheral->state = P_W4_SERVICE_QUERY_RESULT; peripheral->gatt_client_state = P_W4_SERVICE_QUERY_RESULT;
send_gatt_services_request(peripheral); send_gatt_services_request(peripheral);
break; break;
case P_W2_SEND_SERVICE_WITH_UUID_QUERY: case P_W2_SEND_SERVICE_WITH_UUID_QUERY:
peripheral->state = P_W4_SERVICE_WITH_UUID_RESULT; peripheral->gatt_client_state = P_W4_SERVICE_WITH_UUID_RESULT;
send_gatt_services_by_uuid_request(peripheral); send_gatt_services_by_uuid_request(peripheral);
break; break;
case P_W2_SEND_CHARACTERISTIC_QUERY: case P_W2_SEND_CHARACTERISTIC_QUERY:
peripheral->state = P_W4_CHARACTERISTIC_QUERY_RESULT; peripheral->gatt_client_state = P_W4_CHARACTERISTIC_QUERY_RESULT;
send_gatt_characteristic_request(peripheral); send_gatt_characteristic_request(peripheral);
break; break;
case P_W2_SEND_CHARACTERISTIC_WITH_UUID_QUERY: case P_W2_SEND_CHARACTERISTIC_WITH_UUID_QUERY:
peripheral->state = P_W4_CHARACTERISTIC_WITH_UUID_QUERY_RESULT; peripheral->gatt_client_state = P_W4_CHARACTERISTIC_WITH_UUID_QUERY_RESULT;
send_gatt_characteristic_request(peripheral); send_gatt_characteristic_request(peripheral);
break; break;
case P_W2_SEND_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY: case P_W2_SEND_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY:
peripheral->state = P_W4_CHARACTERISTIC_WITH_UUID_QUERY_RESULT; peripheral->gatt_client_state = P_W4_CHARACTERISTIC_WITH_UUID_QUERY_RESULT;
send_gatt_characteristic_descriptor_request(peripheral); send_gatt_characteristic_descriptor_request(peripheral);
break; break;
case P_W2_SEND_INCLUDED_SERVICE_QUERY: case P_W2_SEND_INCLUDED_SERVICE_QUERY:
peripheral->state = P_W4_INCLUDED_SERVICE_QUERY_RESULT; peripheral->gatt_client_state = P_W4_INCLUDED_SERVICE_QUERY_RESULT;
send_gatt_included_service_request(peripheral); send_gatt_included_service_request(peripheral);
break; break;
case P_W2_SEND_INCLUDED_SERVICE_WITH_UUID_QUERY: case P_W2_SEND_INCLUDED_SERVICE_WITH_UUID_QUERY:
peripheral->state = P_W4_INCLUDED_SERVICE_UUID_WITH_QUERY_RESULT; peripheral->gatt_client_state = P_W4_INCLUDED_SERVICE_UUID_WITH_QUERY_RESULT;
send_gatt_included_service_uuid_request(peripheral); send_gatt_included_service_uuid_request(peripheral);
break; break;
case P_W2_SEND_READ_CHARACTERISTIC_VALUE_QUERY: case P_W2_SEND_READ_CHARACTERISTIC_VALUE_QUERY:
peripheral->state = P_W4_READ_CHARACTERISTIC_VALUE_RESULT; peripheral->gatt_client_state = P_W4_READ_CHARACTERISTIC_VALUE_RESULT;
send_gatt_read_characteristic_value_request(peripheral); send_gatt_read_characteristic_value_request(peripheral);
break; break;
case P_W2_SEND_READ_BLOB_QUERY: case P_W2_SEND_READ_BLOB_QUERY:
peripheral->state = P_W4_READ_BLOB_RESULT; peripheral->gatt_client_state = P_W4_READ_BLOB_RESULT;
send_gatt_read_blob_request(peripheral); send_gatt_read_blob_request(peripheral);
break; break;
case P_W2_SEND_WRITE_CHARACTERISTIC_VALUE: case P_W2_SEND_WRITE_CHARACTERISTIC_VALUE:
peripheral->state = P_W4_WRITE_CHARACTERISTIC_VALUE_RESULT; peripheral->gatt_client_state = P_W4_WRITE_CHARACTERISTIC_VALUE_RESULT;
send_gatt_write_attribute_value_request(peripheral); send_gatt_write_attribute_value_request(peripheral);
break; break;
case P_W2_PREPARE_WRITE: case P_W2_PREPARE_WRITE:
peripheral->state = P_W4_PREPARE_WRITE_RESULT; peripheral->gatt_client_state = P_W4_PREPARE_WRITE_RESULT;
send_gatt_prepare_write_request(peripheral); send_gatt_prepare_write_request(peripheral);
break; break;
case P_W2_PREPARE_RELIABLE_WRITE: case P_W2_PREPARE_RELIABLE_WRITE:
peripheral->state = P_W4_PREPARE_RELIABLE_WRITE_RESULT; peripheral->gatt_client_state = P_W4_PREPARE_RELIABLE_WRITE_RESULT;
send_gatt_prepare_write_request(peripheral); send_gatt_prepare_write_request(peripheral);
break; break;
case P_W2_EXECUTE_PREPARED_WRITE: case P_W2_EXECUTE_PREPARED_WRITE:
peripheral->state = P_W4_EXECUTE_PREPARED_WRITE_RESULT; peripheral->gatt_client_state = P_W4_EXECUTE_PREPARED_WRITE_RESULT;
send_gatt_execute_write_request(peripheral); send_gatt_execute_write_request(peripheral);
break; break;
case P_W2_CANCEL_PREPARED_WRITE: case P_W2_CANCEL_PREPARED_WRITE:
peripheral->state = P_W4_CANCEL_PREPARED_WRITE_RESULT; peripheral->gatt_client_state = P_W4_CANCEL_PREPARED_WRITE_RESULT;
send_gatt_cancel_prepared_write_request(peripheral); send_gatt_cancel_prepared_write_request(peripheral);
break; break;
case P_W2_SEND_READ_CLIENT_CHARACTERISTIC_CONFIGURATION_QUERY: case P_W2_SEND_READ_CLIENT_CHARACTERISTIC_CONFIGURATION_QUERY:
peripheral->state = P_W4_READ_CLIENT_CHARACTERISTIC_CONFIGURATION_QUERY_RESULT; peripheral->gatt_client_state = P_W4_READ_CLIENT_CHARACTERISTIC_CONFIGURATION_QUERY_RESULT;
send_gatt_read_client_characteristic_configuration_request(peripheral); send_gatt_read_client_characteristic_configuration_request(peripheral);
break; break;
case P_W2_SEND_READ_CHARACTERISTIC_DESCRIPTOR_QUERY: case P_W2_SEND_READ_CHARACTERISTIC_DESCRIPTOR_QUERY:
peripheral->state = P_W4_READ_CHARACTERISTIC_DESCRIPTOR_RESULT; peripheral->gatt_client_state = P_W4_READ_CHARACTERISTIC_DESCRIPTOR_RESULT;
send_gatt_read_characteristic_descriptor_request(peripheral); send_gatt_read_characteristic_descriptor_request(peripheral);
break; break;
case P_W2_SEND_READ_BLOB_CHARACTERISTIC_DESCRIPTOR_QUERY: case P_W2_SEND_READ_BLOB_CHARACTERISTIC_DESCRIPTOR_QUERY:
peripheral->state = P_W4_READ_BLOB_CHARACTERISTIC_DESCRIPTOR_RESULT; peripheral->gatt_client_state = P_W4_READ_BLOB_CHARACTERISTIC_DESCRIPTOR_RESULT;
send_gatt_read_blob_request(peripheral); send_gatt_read_blob_request(peripheral);
break; break;
case P_W2_SEND_WRITE_CHARACTERISTIC_DESCRIPTOR: case P_W2_SEND_WRITE_CHARACTERISTIC_DESCRIPTOR:
peripheral->state = P_W4_WRITE_CHARACTERISTIC_DESCRIPTOR_RESULT; peripheral->gatt_client_state = P_W4_WRITE_CHARACTERISTIC_DESCRIPTOR_RESULT;
send_gatt_write_attribute_value_request(peripheral); send_gatt_write_attribute_value_request(peripheral);
break; break;
case P_W2_WRITE_CLIENT_CHARACTERISTIC_CONFIGURATION: case P_W2_WRITE_CLIENT_CHARACTERISTIC_CONFIGURATION:
peripheral->state = P_W4_CLIENT_CHARACTERISTIC_CONFIGURATION_RESULT; peripheral->gatt_client_state = P_W4_CLIENT_CHARACTERISTIC_CONFIGURATION_RESULT;
send_gatt_write_client_characteristic_configuration_request(peripheral); send_gatt_write_client_characteristic_configuration_request(peripheral);
break; break;
case P_W2_PREPARE_WRITE_CHARACTERISTIC_DESCRIPTOR: case P_W2_PREPARE_WRITE_CHARACTERISTIC_DESCRIPTOR:
peripheral->state = P_W4_PREPARE_WRITE_CHARACTERISTIC_DESCRIPTOR_RESULT; peripheral->gatt_client_state = P_W4_PREPARE_WRITE_CHARACTERISTIC_DESCRIPTOR_RESULT;
send_gatt_prepare_write_request(peripheral); send_gatt_prepare_write_request(peripheral);
break; break;
case P_W2_EXECUTE_PREPARED_WRITE_CHARACTERISTIC_DESCRIPTOR: case P_W2_EXECUTE_PREPARED_WRITE_CHARACTERISTIC_DESCRIPTOR:
peripheral->state = P_W4_EXECUTE_PREPARED_WRITE_CHARACTERISTIC_DESCRIPTOR_RESULT; peripheral->gatt_client_state = P_W4_EXECUTE_PREPARED_WRITE_CHARACTERISTIC_DESCRIPTOR_RESULT;
send_gatt_execute_write_request(peripheral); send_gatt_execute_write_request(peripheral);
break; break;
default: default:
@ -683,7 +683,7 @@ le_command_status_t le_central_disconnect(gatt_client_t *context){
le_command_status_t gatt_client_discover_primary_services(gatt_client_t *peripheral){ le_command_status_t gatt_client_discover_primary_services(gatt_client_t *peripheral){
peripheral->start_group_handle = 0x0001; peripheral->start_group_handle = 0x0001;
peripheral->end_group_handle = 0xffff; peripheral->end_group_handle = 0xffff;
peripheral->state = P_W2_SEND_SERVICE_QUERY; peripheral->gatt_client_state = P_W2_SEND_SERVICE_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
@ -691,10 +691,10 @@ le_command_status_t gatt_client_discover_primary_services(gatt_client_t *periphe
le_command_status_t gatt_client_discover_primary_services_by_uuid16(gatt_client_t *peripheral, uint16_t uuid16){ le_command_status_t gatt_client_discover_primary_services_by_uuid16(gatt_client_t *peripheral, uint16_t uuid16){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->start_group_handle = 0x0001; peripheral->start_group_handle = 0x0001;
peripheral->end_group_handle = 0xffff; peripheral->end_group_handle = 0xffff;
peripheral->state = P_W2_SEND_SERVICE_WITH_UUID_QUERY; peripheral->gatt_client_state = P_W2_SEND_SERVICE_WITH_UUID_QUERY;
peripheral->uuid16 = uuid16; peripheral->uuid16 = uuid16;
sdp_normalize_uuid((uint8_t*) &(peripheral->uuid128), peripheral->uuid16); sdp_normalize_uuid((uint8_t*) &(peripheral->uuid128), peripheral->uuid16);
gatt_client_run(); gatt_client_run();
@ -702,62 +702,62 @@ le_command_status_t gatt_client_discover_primary_services_by_uuid16(gatt_client_
} }
le_command_status_t gatt_client_discover_primary_services_by_uuid128(gatt_client_t *peripheral, const uint8_t * uuid128){ le_command_status_t gatt_client_discover_primary_services_by_uuid128(gatt_client_t *peripheral, const uint8_t * uuid128){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->start_group_handle = 0x0001; peripheral->start_group_handle = 0x0001;
peripheral->end_group_handle = 0xffff; peripheral->end_group_handle = 0xffff;
peripheral->uuid16 = 0; peripheral->uuid16 = 0;
memcpy(peripheral->uuid128, uuid128, 16); memcpy(peripheral->uuid128, uuid128, 16);
peripheral->state = P_W2_SEND_SERVICE_WITH_UUID_QUERY; peripheral->gatt_client_state = P_W2_SEND_SERVICE_WITH_UUID_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_discover_characteristics_for_service(gatt_client_t *peripheral, le_service_t *service){ le_command_status_t gatt_client_discover_characteristics_for_service(gatt_client_t *peripheral, le_service_t *service){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->start_group_handle = service->start_group_handle; peripheral->start_group_handle = service->start_group_handle;
peripheral->end_group_handle = service->end_group_handle; peripheral->end_group_handle = service->end_group_handle;
peripheral->filter_with_uuid = 0; peripheral->filter_with_uuid = 0;
peripheral->characteristic_start_handle = 0; peripheral->characteristic_start_handle = 0;
peripheral->state = P_W2_SEND_CHARACTERISTIC_QUERY; peripheral->gatt_client_state = P_W2_SEND_CHARACTERISTIC_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_find_included_services_for_service(gatt_client_t *peripheral, le_service_t *service){ le_command_status_t gatt_client_find_included_services_for_service(gatt_client_t *peripheral, le_service_t *service){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->start_group_handle = service->start_group_handle; peripheral->start_group_handle = service->start_group_handle;
peripheral->end_group_handle = service->end_group_handle; peripheral->end_group_handle = service->end_group_handle;
peripheral->state = P_W2_SEND_INCLUDED_SERVICE_QUERY; peripheral->gatt_client_state = P_W2_SEND_INCLUDED_SERVICE_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_discover_characteristics_for_handle_range_by_uuid16(gatt_client_t *peripheral, uint16_t start_handle, uint16_t end_handle, uint16_t uuid16){ le_command_status_t gatt_client_discover_characteristics_for_handle_range_by_uuid16(gatt_client_t *peripheral, uint16_t start_handle, uint16_t end_handle, uint16_t uuid16){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->start_group_handle = start_handle; peripheral->start_group_handle = start_handle;
peripheral->end_group_handle = end_handle; peripheral->end_group_handle = end_handle;
peripheral->filter_with_uuid = 1; peripheral->filter_with_uuid = 1;
peripheral->uuid16 = uuid16; peripheral->uuid16 = uuid16;
sdp_normalize_uuid((uint8_t*) &(peripheral->uuid128), uuid16); sdp_normalize_uuid((uint8_t*) &(peripheral->uuid128), uuid16);
peripheral->characteristic_start_handle = 0; peripheral->characteristic_start_handle = 0;
peripheral->state = P_W2_SEND_CHARACTERISTIC_WITH_UUID_QUERY; peripheral->gatt_client_state = P_W2_SEND_CHARACTERISTIC_WITH_UUID_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_discover_characteristics_for_handle_range_by_uuid128(gatt_client_t *peripheral, uint16_t start_handle, uint16_t end_handle, uint8_t * uuid128){ le_command_status_t gatt_client_discover_characteristics_for_handle_range_by_uuid128(gatt_client_t *peripheral, uint16_t start_handle, uint16_t end_handle, uint8_t * uuid128){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->start_group_handle = start_handle; peripheral->start_group_handle = start_handle;
peripheral->end_group_handle = end_handle; peripheral->end_group_handle = end_handle;
peripheral->filter_with_uuid = 1; peripheral->filter_with_uuid = 1;
peripheral->uuid16 = 0; peripheral->uuid16 = 0;
memcpy(peripheral->uuid128, uuid128, 16); memcpy(peripheral->uuid128, uuid128, 16);
peripheral->characteristic_start_handle = 0; peripheral->characteristic_start_handle = 0;
peripheral->state = P_W2_SEND_CHARACTERISTIC_WITH_UUID_QUERY; peripheral->gatt_client_state = P_W2_SEND_CHARACTERISTIC_WITH_UUID_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
@ -773,24 +773,24 @@ le_command_status_t gatt_client_discover_characteristics_for_service_by_uuid128(
} }
le_command_status_t gatt_client_discover_characteristic_descriptors(gatt_client_t *peripheral, le_characteristic_t *characteristic){ le_command_status_t gatt_client_discover_characteristic_descriptors(gatt_client_t *peripheral, le_characteristic_t *characteristic){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
if (characteristic->value_handle == characteristic->end_handle){ if (characteristic->value_handle == characteristic->end_handle){
send_gatt_complete_event(peripheral, GATT_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_COMPLETE, 0); send_gatt_complete_event(peripheral, GATT_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_COMPLETE, 0);
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
peripheral->start_group_handle = characteristic->value_handle + 1; peripheral->start_group_handle = characteristic->value_handle + 1;
peripheral->end_group_handle = characteristic->end_handle; peripheral->end_group_handle = characteristic->end_handle;
peripheral->state = P_W2_SEND_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY; peripheral->gatt_client_state = P_W2_SEND_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_read_value_of_characteristic_using_value_handle(gatt_client_t *peripheral, uint16_t value_handle){ le_command_status_t gatt_client_read_value_of_characteristic_using_value_handle(gatt_client_t *peripheral, uint16_t value_handle){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->attribute_handle = value_handle; peripheral->attribute_handle = value_handle;
peripheral->attribute_offset = 0; peripheral->attribute_offset = 0;
peripheral->state = P_W2_SEND_READ_CHARACTERISTIC_VALUE_QUERY; peripheral->gatt_client_state = P_W2_SEND_READ_CHARACTERISTIC_VALUE_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
@ -801,10 +801,10 @@ le_command_status_t gatt_client_read_value_of_characteristic(gatt_client_t *peri
le_command_status_t gatt_client_read_long_value_of_characteristic_using_value_handle(gatt_client_t *peripheral, uint16_t value_handle){ le_command_status_t gatt_client_read_long_value_of_characteristic_using_value_handle(gatt_client_t *peripheral, uint16_t value_handle){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->attribute_handle = value_handle; peripheral->attribute_handle = value_handle;
peripheral->attribute_offset = 0; peripheral->attribute_offset = 0;
peripheral->state = P_W2_SEND_READ_BLOB_QUERY; peripheral->gatt_client_state = P_W2_SEND_READ_BLOB_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
@ -828,7 +828,7 @@ static int is_connected(gatt_client_t * peripheral){
} }
le_command_status_t gatt_client_write_value_of_characteristic_without_response(gatt_client_t *peripheral, uint16_t value_handle, uint16_t value_length, uint8_t * value){ le_command_status_t gatt_client_write_value_of_characteristic_without_response(gatt_client_t *peripheral, uint16_t value_handle, uint16_t value_length, uint8_t * value){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
if (value_length >= peripheral->mtu - 3) return BLE_VALUE_TOO_LONG; if (value_length >= peripheral->mtu - 3) return BLE_VALUE_TOO_LONG;
if (!is_connected(peripheral)) return BLE_PERIPHERAL_IN_WRONG_STATE; if (!is_connected(peripheral)) return BLE_PERIPHERAL_IN_WRONG_STATE;
@ -837,41 +837,41 @@ le_command_status_t gatt_client_write_value_of_characteristic_without_response(g
} }
le_command_status_t gatt_client_write_value_of_characteristic(gatt_client_t *peripheral, uint16_t value_handle, uint16_t value_length, uint8_t * value){ le_command_status_t gatt_client_write_value_of_characteristic(gatt_client_t *peripheral, uint16_t value_handle, uint16_t value_length, uint8_t * value){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
if (value_length >= peripheral->mtu - 3) return BLE_VALUE_TOO_LONG; if (value_length >= peripheral->mtu - 3) return BLE_VALUE_TOO_LONG;
peripheral->attribute_handle = value_handle; peripheral->attribute_handle = value_handle;
peripheral->attribute_length = value_length; peripheral->attribute_length = value_length;
peripheral->attribute_value = value; peripheral->attribute_value = value;
peripheral->state = P_W2_SEND_WRITE_CHARACTERISTIC_VALUE; peripheral->gatt_client_state = P_W2_SEND_WRITE_CHARACTERISTIC_VALUE;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_write_long_value_of_characteristic(gatt_client_t *peripheral, uint16_t value_handle, uint16_t value_length, uint8_t * value){ le_command_status_t gatt_client_write_long_value_of_characteristic(gatt_client_t *peripheral, uint16_t value_handle, uint16_t value_length, uint8_t * value){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->attribute_handle = value_handle; peripheral->attribute_handle = value_handle;
peripheral->attribute_length = value_length; peripheral->attribute_length = value_length;
peripheral->attribute_offset = 0; peripheral->attribute_offset = 0;
peripheral->attribute_value = value; peripheral->attribute_value = value;
peripheral->state = P_W2_PREPARE_WRITE; peripheral->gatt_client_state = P_W2_PREPARE_WRITE;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_reliable_write_long_value_of_characteristic(gatt_client_t *peripheral, uint16_t value_handle, uint16_t value_length, uint8_t * value){ le_command_status_t gatt_client_reliable_write_long_value_of_characteristic(gatt_client_t *peripheral, uint16_t value_handle, uint16_t value_length, uint8_t * value){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->attribute_handle = value_handle; peripheral->attribute_handle = value_handle;
peripheral->attribute_length = value_length; peripheral->attribute_length = value_length;
peripheral->attribute_offset = 0; peripheral->attribute_offset = 0;
peripheral->attribute_value = value; peripheral->attribute_value = value;
peripheral->state = P_W2_PREPARE_RELIABLE_WRITE; peripheral->gatt_client_state = P_W2_PREPARE_RELIABLE_WRITE;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_write_client_characteristic_configuration(gatt_client_t *peripheral, le_characteristic_t * characteristic, uint16_t configuration){ le_command_status_t gatt_client_write_client_characteristic_configuration(gatt_client_t *peripheral, le_characteristic_t * characteristic, uint16_t configuration){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
if ( (configuration & GATT_CLIENT_CHARACTERISTICS_CONFIGURATION_NOTIFICATION) && if ( (configuration & GATT_CLIENT_CHARACTERISTICS_CONFIGURATION_NOTIFICATION) &&
(characteristic->properties & ATT_PROPERTY_NOTIFY) == 0) { (characteristic->properties & ATT_PROPERTY_NOTIFY) == 0) {
log_info("le_central_write_client_characteristic_configuration: BLE_CHARACTERISTIC_NOTIFICATION_NOT_SUPPORTED"); log_info("le_central_write_client_characteristic_configuration: BLE_CHARACTERISTIC_NOTIFICATION_NOT_SUPPORTED");
@ -886,13 +886,13 @@ le_command_status_t gatt_client_write_client_characteristic_configuration(gatt_c
peripheral->end_group_handle = characteristic->end_handle; peripheral->end_group_handle = characteristic->end_handle;
bt_store_16(peripheral->client_characteristic_configuration_value, 0, configuration); bt_store_16(peripheral->client_characteristic_configuration_value, 0, configuration);
peripheral->state = P_W2_SEND_READ_CLIENT_CHARACTERISTIC_CONFIGURATION_QUERY; peripheral->gatt_client_state = P_W2_SEND_READ_CLIENT_CHARACTERISTIC_CONFIGURATION_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_read_characteristic_descriptor(gatt_client_t *peripheral, le_characteristic_descriptor_t * descriptor){ le_command_status_t gatt_client_read_characteristic_descriptor(gatt_client_t *peripheral, le_characteristic_descriptor_t * descriptor){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->attribute_handle = descriptor->handle; peripheral->attribute_handle = descriptor->handle;
peripheral->uuid16 = descriptor->uuid16; peripheral->uuid16 = descriptor->uuid16;
@ -900,40 +900,40 @@ le_command_status_t gatt_client_read_characteristic_descriptor(gatt_client_t *pe
memcpy(peripheral->uuid128, descriptor->uuid128, 16); memcpy(peripheral->uuid128, descriptor->uuid128, 16);
} }
peripheral->state = P_W2_SEND_READ_CHARACTERISTIC_DESCRIPTOR_QUERY; peripheral->gatt_client_state = P_W2_SEND_READ_CHARACTERISTIC_DESCRIPTOR_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_read_long_characteristic_descriptor(gatt_client_t *peripheral, le_characteristic_descriptor_t * descriptor){ le_command_status_t gatt_client_read_long_characteristic_descriptor(gatt_client_t *peripheral, le_characteristic_descriptor_t * descriptor){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->attribute_handle = descriptor->handle; peripheral->attribute_handle = descriptor->handle;
peripheral->attribute_offset = 0; peripheral->attribute_offset = 0;
peripheral->state = P_W2_SEND_READ_BLOB_CHARACTERISTIC_DESCRIPTOR_QUERY; peripheral->gatt_client_state = P_W2_SEND_READ_BLOB_CHARACTERISTIC_DESCRIPTOR_QUERY;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_write_characteristic_descriptor(gatt_client_t *peripheral, le_characteristic_descriptor_t * descriptor, uint16_t length, uint8_t * value){ le_command_status_t gatt_client_write_characteristic_descriptor(gatt_client_t *peripheral, le_characteristic_descriptor_t * descriptor, uint16_t length, uint8_t * value){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->attribute_handle = descriptor->handle; peripheral->attribute_handle = descriptor->handle;
peripheral->attribute_length = length; peripheral->attribute_length = length;
peripheral->attribute_offset = 0; peripheral->attribute_offset = 0;
peripheral->attribute_value = value; peripheral->attribute_value = value;
peripheral->state = P_W2_SEND_WRITE_CHARACTERISTIC_DESCRIPTOR; peripheral->gatt_client_state = P_W2_SEND_WRITE_CHARACTERISTIC_DESCRIPTOR;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
le_command_status_t gatt_client_write_long_characteristic_descriptor(gatt_client_t *peripheral, le_characteristic_descriptor_t * descriptor, uint16_t length, uint8_t * value){ le_command_status_t gatt_client_write_long_characteristic_descriptor(gatt_client_t *peripheral, le_characteristic_descriptor_t * descriptor, uint16_t length, uint8_t * value){
if (peripheral->state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE; if (peripheral->gatt_client_state != P_READY) return BLE_PERIPHERAL_IN_WRONG_STATE;
peripheral->attribute_handle = descriptor->handle; peripheral->attribute_handle = descriptor->handle;
peripheral->attribute_length = length; peripheral->attribute_length = length;
peripheral->attribute_offset = 0; peripheral->attribute_offset = 0;
peripheral->attribute_value = value; peripheral->attribute_value = value;
peripheral->state = P_W2_PREPARE_WRITE_CHARACTERISTIC_DESCRIPTOR; peripheral->gatt_client_state = P_W2_PREPARE_WRITE_CHARACTERISTIC_DESCRIPTOR;
gatt_client_run(); gatt_client_run();
return BLE_PERIPHERAL_OK; return BLE_PERIPHERAL_OK;
} }
@ -1040,7 +1040,7 @@ static void packet_handler(void * connection, uint8_t packet_type, uint16_t chan
linked_list_remove(&le_connections, (linked_item_t *) peripheral); linked_list_remove(&le_connections, (linked_item_t *) peripheral);
} else { } else {
peripheral->le_central_state = P_CONNECTED; peripheral->le_central_state = P_CONNECTED;
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
peripheral->handle = READ_BT_16(packet, 4); peripheral->handle = READ_BT_16(packet, 4);
} }
break; break;
@ -1284,11 +1284,11 @@ static void report_gatt_all_characteristic_descriptors(gatt_client_t * periphera
static void trigger_next_query(gatt_client_t * peripheral, uint16_t last_result_handle, gatt_client_state_t next_query_state, uint8_t complete_event_type){ static void trigger_next_query(gatt_client_t * peripheral, uint16_t last_result_handle, gatt_client_state_t next_query_state, uint8_t complete_event_type){
if (last_result_handle < peripheral->end_group_handle){ if (last_result_handle < peripheral->end_group_handle){
peripheral->start_group_handle = last_result_handle + 1; peripheral->start_group_handle = last_result_handle + 1;
peripheral->state = next_query_state; peripheral->gatt_client_state = next_query_state;
return; return;
} }
// DONE // DONE
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, complete_event_type, 0); send_gatt_complete_event(peripheral, complete_event_type, 0);
} }
@ -1322,23 +1322,23 @@ static inline void trigger_next_prepare_write_query(gatt_client_t * peripheral,
uint16_t next_blob_length = write_blob_length(peripheral); uint16_t next_blob_length = write_blob_length(peripheral);
if (next_blob_length == 0){ if (next_blob_length == 0){
peripheral->state = done_state; peripheral->gatt_client_state = done_state;
return; return;
} }
peripheral->state = next_query_state; peripheral->gatt_client_state = next_query_state;
} }
static inline void trigger_next_blob_query(gatt_client_t * peripheral, gatt_client_state_t next_query_state, uint8_t done_event, uint16_t received_blob_length){ static inline void trigger_next_blob_query(gatt_client_t * peripheral, gatt_client_state_t next_query_state, uint8_t done_event, uint16_t received_blob_length){
uint16_t max_blob_length = peripheral->mtu - 1; uint16_t max_blob_length = peripheral->mtu - 1;
if (received_blob_length < max_blob_length){ if (received_blob_length < max_blob_length){
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, done_event, 0); send_gatt_complete_event(peripheral, done_event, 0);
return; return;
} }
peripheral->attribute_offset += received_blob_length; peripheral->attribute_offset += received_blob_length;
peripheral->state = next_query_state; peripheral->gatt_client_state = next_query_state;
} }
static int is_value_valid(gatt_client_t *peripheral, uint8_t *packet, uint16_t size){ static int is_value_valid(gatt_client_t *peripheral, uint8_t *packet, uint16_t size){
@ -1366,7 +1366,7 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
break; break;
} }
case ATT_READ_BY_GROUP_TYPE_RESPONSE: case ATT_READ_BY_GROUP_TYPE_RESPONSE:
switch(peripheral->state){ switch(peripheral->gatt_client_state){
case P_W4_SERVICE_QUERY_RESULT: case P_W4_SERVICE_QUERY_RESULT:
report_gatt_services(peripheral, packet, size); report_gatt_services(peripheral, packet, size);
trigger_next_service_query(peripheral, get_last_result_handle(packet, size)); trigger_next_service_query(peripheral, get_last_result_handle(packet, size));
@ -1386,7 +1386,7 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
break; break;
case ATT_READ_BY_TYPE_RESPONSE: case ATT_READ_BY_TYPE_RESPONSE:
switch (peripheral->state){ switch (peripheral->gatt_client_state){
case P_W4_CHARACTERISTIC_QUERY_RESULT: case P_W4_CHARACTERISTIC_QUERY_RESULT:
report_gatt_characteristics(peripheral, packet, size); report_gatt_characteristics(peripheral, packet, size);
trigger_next_characteristic_query(peripheral, get_last_result_handle(packet, size)); trigger_next_characteristic_query(peripheral, get_last_result_handle(packet, size));
@ -1405,7 +1405,7 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
peripheral->start_group_handle = READ_BT_16(packet, 2); // ready for next query peripheral->start_group_handle = READ_BT_16(packet, 2); // ready for next query
peripheral->query_start_handle = READ_BT_16(packet, 4); peripheral->query_start_handle = READ_BT_16(packet, 4);
peripheral->query_end_handle = READ_BT_16(packet,6); peripheral->query_end_handle = READ_BT_16(packet,6);
peripheral->state = P_W2_SEND_INCLUDED_SERVICE_WITH_UUID_QUERY; peripheral->gatt_client_state = P_W2_SEND_INCLUDED_SERVICE_WITH_UUID_QUERY;
break; break;
} }
@ -1422,14 +1422,14 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
} }
case P_W4_READ_CLIENT_CHARACTERISTIC_CONFIGURATION_QUERY_RESULT: case P_W4_READ_CLIENT_CHARACTERISTIC_CONFIGURATION_QUERY_RESULT:
peripheral->client_characteristic_configuration_handle = READ_BT_16(packet, 2); peripheral->client_characteristic_configuration_handle = READ_BT_16(packet, 2);
peripheral->state = P_W2_WRITE_CLIENT_CHARACTERISTIC_CONFIGURATION; peripheral->gatt_client_state = P_W2_WRITE_CLIENT_CHARACTERISTIC_CONFIGURATION;
break; break;
default: default:
break; break;
} }
break; break;
case ATT_READ_RESPONSE: case ATT_READ_RESPONSE:
switch (peripheral->state){ switch (peripheral->gatt_client_state){
case P_W4_INCLUDED_SERVICE_UUID_WITH_QUERY_RESULT: { case P_W4_INCLUDED_SERVICE_UUID_WITH_QUERY_RESULT: {
uint8_t uuid128[16]; uint8_t uuid128[16];
swap128(&packet[1], uuid128); swap128(&packet[1], uuid128);
@ -1438,12 +1438,12 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
break; break;
} }
case P_W4_READ_CHARACTERISTIC_VALUE_RESULT: case P_W4_READ_CHARACTERISTIC_VALUE_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
report_gatt_characteristic_value(peripheral, peripheral->attribute_handle, &packet[1], size-1); report_gatt_characteristic_value(peripheral, peripheral->attribute_handle, &packet[1], size-1);
break; break;
case P_W4_READ_CHARACTERISTIC_DESCRIPTOR_RESULT:{ case P_W4_READ_CHARACTERISTIC_DESCRIPTOR_RESULT:{
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
report_gatt_characteristic_descriptor(peripheral, peripheral->attribute_handle, &packet[1], size-1, 0, GATT_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT); report_gatt_characteristic_descriptor(peripheral, peripheral->attribute_handle, &packet[1], size-1, 0, GATT_CHARACTERISTIC_DESCRIPTOR_QUERY_RESULT);
break; break;
} }
@ -1487,17 +1487,17 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
} }
case ATT_WRITE_RESPONSE: case ATT_WRITE_RESPONSE:
switch (peripheral->state){ switch (peripheral->gatt_client_state){
case P_W4_WRITE_CHARACTERISTIC_VALUE_RESULT: case P_W4_WRITE_CHARACTERISTIC_VALUE_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_CHARACTERISTIC_VALUE_WRITE_RESPONSE, 0); send_gatt_complete_event(peripheral, GATT_CHARACTERISTIC_VALUE_WRITE_RESPONSE, 0);
break; break;
case P_W4_CLIENT_CHARACTERISTIC_CONFIGURATION_RESULT: case P_W4_CLIENT_CHARACTERISTIC_CONFIGURATION_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_COMPLETE, 0); send_gatt_complete_event(peripheral, GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_COMPLETE, 0);
break; break;
case P_W4_WRITE_CHARACTERISTIC_DESCRIPTOR_RESULT: case P_W4_WRITE_CHARACTERISTIC_DESCRIPTOR_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_CHARACTERISTIC_DESCRIPTOR_WRITE_RESPONSE, 0); send_gatt_complete_event(peripheral, GATT_CHARACTERISTIC_DESCRIPTOR_WRITE_RESPONSE, 0);
break; break;
default: default:
@ -1508,7 +1508,7 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
case ATT_READ_BLOB_RESPONSE:{ case ATT_READ_BLOB_RESPONSE:{
uint16_t received_blob_length = size-1; uint16_t received_blob_length = size-1;
switch(peripheral->state){ switch(peripheral->gatt_client_state){
case P_W4_READ_BLOB_RESULT: case P_W4_READ_BLOB_RESULT:
report_gatt_long_characteristic_value_blob(peripheral, &packet[1], received_blob_length, peripheral->attribute_offset); report_gatt_long_characteristic_value_blob(peripheral, &packet[1], received_blob_length, peripheral->attribute_offset);
trigger_next_blob_query(peripheral, P_W2_SEND_READ_BLOB_QUERY, GATT_LONG_CHARACTERISTIC_VALUE_QUERY_COMPLETE, received_blob_length); trigger_next_blob_query(peripheral, P_W2_SEND_READ_BLOB_QUERY, GATT_LONG_CHARACTERISTIC_VALUE_QUERY_COMPLETE, received_blob_length);
@ -1525,7 +1525,7 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
break; break;
} }
case ATT_PREPARE_WRITE_RESPONSE: case ATT_PREPARE_WRITE_RESPONSE:
switch (peripheral->state){ switch (peripheral->gatt_client_state){
case P_W4_PREPARE_WRITE_RESULT:{ case P_W4_PREPARE_WRITE_RESULT:{
peripheral->attribute_offset = READ_BT_16(packet, 3); peripheral->attribute_offset = READ_BT_16(packet, 3);
trigger_next_prepare_write_query(peripheral, P_W2_PREPARE_WRITE, P_W2_EXECUTE_PREPARED_WRITE); trigger_next_prepare_write_query(peripheral, P_W2_PREPARE_WRITE, P_W2_EXECUTE_PREPARED_WRITE);
@ -1542,7 +1542,7 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
trigger_next_prepare_write_query(peripheral, P_W2_PREPARE_RELIABLE_WRITE, P_W2_EXECUTE_PREPARED_WRITE); trigger_next_prepare_write_query(peripheral, P_W2_PREPARE_RELIABLE_WRITE, P_W2_EXECUTE_PREPARED_WRITE);
break; break;
} }
peripheral->state = P_W2_CANCEL_PREPARED_WRITE; peripheral->gatt_client_state = P_W2_CANCEL_PREPARED_WRITE;
break; break;
} }
default: default:
@ -1551,17 +1551,17 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
break; break;
case ATT_EXECUTE_WRITE_RESPONSE: case ATT_EXECUTE_WRITE_RESPONSE:
switch (peripheral->state){ switch (peripheral->gatt_client_state){
case P_W4_EXECUTE_PREPARED_WRITE_RESULT: case P_W4_EXECUTE_PREPARED_WRITE_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_LONG_CHARACTERISTIC_VALUE_WRITE_COMPLETE, 0); send_gatt_complete_event(peripheral, GATT_LONG_CHARACTERISTIC_VALUE_WRITE_COMPLETE, 0);
break; break;
case P_W4_CANCEL_PREPARED_WRITE_RESULT: case P_W4_CANCEL_PREPARED_WRITE_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_LONG_CHARACTERISTIC_VALUE_WRITE_CANCELED, 1); send_gatt_complete_event(peripheral, GATT_LONG_CHARACTERISTIC_VALUE_WRITE_CANCELED, 1);
break; break;
case P_W4_EXECUTE_PREPARED_WRITE_CHARACTERISTIC_DESCRIPTOR_RESULT: case P_W4_EXECUTE_PREPARED_WRITE_CHARACTERISTIC_DESCRIPTOR_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_LONG_CHARACTERISTIC_DESCRIPTOR_WRITE_COMPLETE, 0); send_gatt_complete_event(peripheral, GATT_LONG_CHARACTERISTIC_DESCRIPTOR_WRITE_COMPLETE, 0);
break; break;
default: default:
@ -1574,38 +1574,38 @@ static void gatt_client_att_packet_handler(uint8_t packet_type, uint16_t handle,
// printf("ATT_ERROR_RESPONSE error %u, state %u\n", packet[4], peripheral->state); // printf("ATT_ERROR_RESPONSE error %u, state %u\n", packet[4], peripheral->state);
switch (packet[4]){ switch (packet[4]){
case ATT_ERROR_ATTRIBUTE_NOT_FOUND: { case ATT_ERROR_ATTRIBUTE_NOT_FOUND: {
switch(peripheral->state){ switch(peripheral->gatt_client_state){
case P_W4_SERVICE_QUERY_RESULT: case P_W4_SERVICE_QUERY_RESULT:
case P_W4_SERVICE_WITH_UUID_RESULT: case P_W4_SERVICE_WITH_UUID_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_SERVICE_QUERY_COMPLETE, 0); send_gatt_complete_event(peripheral, GATT_SERVICE_QUERY_COMPLETE, 0);
break; break;
case P_W4_CHARACTERISTIC_QUERY_RESULT: case P_W4_CHARACTERISTIC_QUERY_RESULT:
case P_W4_CHARACTERISTIC_WITH_UUID_QUERY_RESULT: case P_W4_CHARACTERISTIC_WITH_UUID_QUERY_RESULT:
characteristic_end_found(peripheral, peripheral->end_group_handle); characteristic_end_found(peripheral, peripheral->end_group_handle);
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_CHARACTERISTIC_QUERY_COMPLETE, 0); send_gatt_complete_event(peripheral, GATT_CHARACTERISTIC_QUERY_COMPLETE, 0);
break; break;
case P_W4_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_RESULT: case P_W4_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_COMPLETE, 0); send_gatt_complete_event(peripheral, GATT_ALL_CHARACTERISTIC_DESCRIPTORS_QUERY_COMPLETE, 0);
break; break;
case P_W4_INCLUDED_SERVICE_QUERY_RESULT: case P_W4_INCLUDED_SERVICE_QUERY_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_INCLUDED_SERVICE_QUERY_COMPLETE, 0); send_gatt_complete_event(peripheral, GATT_INCLUDED_SERVICE_QUERY_COMPLETE, 0);
break; break;
case P_W4_READ_BLOB_RESULT: case P_W4_READ_BLOB_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_LONG_CHARACTERISTIC_VALUE_QUERY_COMPLETE, 0); send_gatt_complete_event(peripheral, GATT_LONG_CHARACTERISTIC_VALUE_QUERY_COMPLETE, 0);
break; break;
case P_W4_READ_CLIENT_CHARACTERISTIC_CONFIGURATION_QUERY_RESULT: case P_W4_READ_CLIENT_CHARACTERISTIC_CONFIGURATION_QUERY_RESULT:
peripheral->state = P_READY; peripheral->gatt_client_state = P_READY;
send_gatt_complete_event(peripheral, GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_COMPLETE, 0); send_gatt_complete_event(peripheral, GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_COMPLETE, 0);
break; break;
default: default:
printf("ATT_ERROR_ATTRIBUTE_NOT_FOUND in %d\n", peripheral->state); printf("ATT_ERROR_ATTRIBUTE_NOT_FOUND in %d\n", peripheral->gatt_client_state);
return; return;
} }

2
example/libusb/ble_client.h
View File

@ -172,7 +172,7 @@ typedef struct le_peripheral_connection{
typedef struct gatt_client{ typedef struct gatt_client{
linked_item_t item; linked_item_t item;
gatt_client_state_t state; gatt_client_state_t gatt_client_state;
le_central_state_t le_central_state; le_central_state_t le_central_state;
uint16_t handle; uint16_t handle;