jeans/esphome
jeans/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2025-08-02 08:27:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

[bluetooth_proxy] Batch BLE service discovery messages for 67% reduction in API traffic (#9992)

Browse Source
This commit is contained in:
J. Nick Koston 2025-07-30 18:11:11 -10:00 committed by GitHub
parent 88cfcc1967
commit 71557c9f58
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 109 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
esphome/components/api/api.proto
View File

@ -1505,7 +1505,7 @@ message BluetoothGATTGetServicesResponse {
option (ifdef) = "USE_BLUETOOTH_PROXY"; option (ifdef) = "USE_BLUETOOTH_PROXY";
uint64 address = 1; uint64 address = 1;
repeated BluetoothGATTService services = 2 [(fixed_array_size) = 1]; repeated BluetoothGATTService services = 2;
} }
message BluetoothGATTGetServicesDoneResponse { message BluetoothGATTGetServicesDoneResponse {

6
esphome/components/api/api_pb2.cpp
View File

@ -1929,11 +1929,13 @@ void BluetoothGATTService::calculate_size(ProtoSize &size) const {
} }
void BluetoothGATTGetServicesResponse::encode(ProtoWriteBuffer buffer) const { void BluetoothGATTGetServicesResponse::encode(ProtoWriteBuffer buffer) const {
buffer.encode_uint64(1, this->address); buffer.encode_uint64(1, this->address);
buffer.encode_message(2, this->services[0], true); for (auto &it : this->services) {
buffer.encode_message(2, it, true);
}
} }
void BluetoothGATTGetServicesResponse::calculate_size(ProtoSize &size) const { void BluetoothGATTGetServicesResponse::calculate_size(ProtoSize &size) const {
size.add_uint64(1, this->address); size.add_uint64(1, this->address);
size.add_message_object_force(1, this->services[0]); size.add_repeated_message(1, this->services);
} }
void BluetoothGATTGetServicesDoneResponse::encode(ProtoWriteBuffer buffer) const { void BluetoothGATTGetServicesDoneResponse::encode(ProtoWriteBuffer buffer) const {
buffer.encode_uint64(1, this->address); buffer.encode_uint64(1, this->address);

4
esphome/components/api/api_pb2.h
View File

@ -1895,12 +1895,12 @@ class BluetoothGATTService : public ProtoMessage {
class BluetoothGATTGetServicesResponse : public ProtoMessage { class BluetoothGATTGetServicesResponse : public ProtoMessage {
public: public:
static constexpr uint8_t MESSAGE_TYPE = 71; static constexpr uint8_t MESSAGE_TYPE = 71;
static constexpr uint8_t ESTIMATED_SIZE = 21; static constexpr uint8_t ESTIMATED_SIZE = 38;
#ifdef HAS_PROTO_MESSAGE_DUMP #ifdef HAS_PROTO_MESSAGE_DUMP
const char *message_name() const override { return "bluetooth_gatt_get_services_response"; } const char *message_name() const override { return "bluetooth_gatt_get_services_response"; }
#endif #endif
uint64_t address{0}; uint64_t address{0};
std::array<BluetoothGATTService, 1> services{}; std::vector<BluetoothGATTService> services{};
void encode(ProtoWriteBuffer buffer) const override; void encode(ProtoWriteBuffer buffer) const override;
void calculate_size(ProtoSize &size) const override; void calculate_size(ProtoSize &size) const override;
#ifdef HAS_PROTO_MESSAGE_DUMP #ifdef HAS_PROTO_MESSAGE_DUMP

188
esphome/components/bluetooth_proxy/bluetooth_connection.cpp
View File

@ -57,7 +57,7 @@ void BluetoothConnection::reset_connection_(esp_err_t reason) {
} }
void BluetoothConnection::send_service_for_discovery_() { void BluetoothConnection::send_service_for_discovery_() {
if (this->send_service_ == this->service_count_) { if (this->send_service_ >= this->service_count_) {
this->send_service_ = DONE_SENDING_SERVICES; this->send_service_ = DONE_SENDING_SERVICES;
this->proxy_->send_gatt_services_done(this->address_); this->proxy_->send_gatt_services_done(this->address_);
if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE || if (this->connection_type_ == espbt::ConnectionType::V3_WITH_CACHE ||
@ -70,119 +70,133 @@ void BluetoothConnection::send_service_for_discovery_() {
// Early return if no API connection // Early return if no API connection
auto *api_conn = this->proxy_->get_api_connection(); auto *api_conn = this->proxy_->get_api_connection();
if (api_conn == nullptr) { if (api_conn == nullptr) {
this->send_service_ = DONE_SENDING_SERVICES;
return; return;
} }
// Send next service // Prepare response for up to 3 services
esp_gattc_service_elem_t service_result;
uint16_t service_count = 1;
esp_gatt_status_t service_status = esp_ble_gattc_get_service(this->gattc_if_, this->conn_id_, nullptr,
&service_result, &service_count, this->send_service_);
this->send_service_++;
if (service_status != ESP_GATT_OK || service_count == 0) {
ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_service %s, status=%d, service_count=%d, offset=%d",
this->connection_index_, this->address_str().c_str(), service_status != ESP_GATT_OK ? "error" : "missing",
service_status, service_count, this->send_service_ - 1);
return;
}
api::BluetoothGATTGetServicesResponse resp; api::BluetoothGATTGetServicesResponse resp;
resp.address = this->address_; resp.address = this->address_;
auto &service_resp = resp.services[0];
fill_128bit_uuid_array(service_resp.uuid, service_result.uuid);
service_resp.handle = service_result.start_handle;
// Get the number of characteristics directly with one call // Process up to 3 services in this iteration
uint16_t total_char_count = 0; uint8_t services_to_process =
esp_gatt_status_t char_count_status = std::min(MAX_SERVICES_PER_BATCH, static_cast<uint8_t>(this->service_count_ - this->send_service_));
esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_CHARACTERISTIC, resp.services.reserve(services_to_process);
service_result.start_handle, service_result.end_handle, 0, &total_char_count);
if (char_count_status != ESP_GATT_OK) { for (int service_idx = 0; service_idx < services_to_process; service_idx++) {
ESP_LOGW(TAG, "[%d] [%s] Error getting characteristic count, status=%d", this->connection_index_, esp_gattc_service_elem_t service_result;
this->address_str().c_str(), char_count_status); uint16_t service_count = 1;
return; esp_gatt_status_t service_status = esp_ble_gattc_get_service(this->gattc_if_, this->conn_id_, nullptr,
} &service_result, &service_count, this->send_service_);
if (total_char_count == 0) { if (service_status != ESP_GATT_OK || service_count == 0) {
// No characteristics, just send the service response ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_service %s, status=%d, service_count=%d, offset=%d",
api_conn->send_message(resp, api::BluetoothGATTGetServicesResponse::MESSAGE_TYPE); this->connection_index_, this->address_str().c_str(),
return; service_status != ESP_GATT_OK ? "error" : "missing", service_status, service_count, this->send_service_);
} this->send_service_ = DONE_SENDING_SERVICES;
// Reserve space and process characteristics
service_resp.characteristics.reserve(total_char_count);
uint16_t char_offset = 0;
esp_gattc_char_elem_t char_result;
while (true) { // characteristics
uint16_t char_count = 1;
esp_gatt_status_t char_status =
esp_ble_gattc_get_all_char(this->gattc_if_, this->conn_id_, service_result.start_handle,
service_result.end_handle, &char_result, &char_count, char_offset);
if (char_status == ESP_GATT_INVALID_OFFSET || char_status == ESP_GATT_NOT_FOUND) {
break;
}
if (char_status != ESP_GATT_OK) {
ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_char error, status=%d", this->connection_index_,
this->address_str().c_str(), char_status);
return; return;
} }
if (char_count == 0) {
break;
}
service_resp.characteristics.emplace_back(); this->send_service_++;
auto &characteristic_resp = service_resp.characteristics.back(); resp.services.emplace_back();
fill_128bit_uuid_array(characteristic_resp.uuid, char_result.uuid); auto &service_resp = resp.services.back();
characteristic_resp.handle = char_result.char_handle; fill_128bit_uuid_array(service_resp.uuid, service_result.uuid);
characteristic_resp.properties = char_result.properties; service_resp.handle = service_result.start_handle;
char_offset++;
// Get the number of descriptors directly with one call // Get the number of characteristics directly with one call
uint16_t total_desc_count = 0; uint16_t total_char_count = 0;
esp_gatt_status_t desc_count_status = esp_ble_gattc_get_attr_count( esp_gatt_status_t char_count_status =
this->gattc_if_, this->conn_id_, ESP_GATT_DB_DESCRIPTOR, 0, 0, char_result.char_handle, &total_desc_count); esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_CHARACTERISTIC,
service_result.start_handle, service_result.end_handle, 0, &total_char_count);
if (desc_count_status != ESP_GATT_OK) { if (char_count_status != ESP_GATT_OK) {
ESP_LOGW(TAG, "[%d] [%s] Error getting descriptor count for char handle %d, status=%d", this->connection_index_, ESP_LOGE(TAG, "[%d] [%s] Error getting characteristic count, status=%d", this->connection_index_,
this->address_str().c_str(), char_result.char_handle, desc_count_status); this->address_str().c_str(), char_count_status);
this->send_service_ = DONE_SENDING_SERVICES;
return; return;
} }
if (total_desc_count == 0) {
// No descriptors, continue to next characteristic if (total_char_count == 0) {
// No characteristics, continue to next service
continue; continue;
} }
// Reserve space and process descriptors // Reserve space and process characteristics
characteristic_resp.descriptors.reserve(total_desc_count); service_resp.characteristics.reserve(total_char_count);
uint16_t desc_offset = 0; uint16_t char_offset = 0;
esp_gattc_descr_elem_t desc_result; esp_gattc_char_elem_t char_result;
while (true) { // descriptors while (true) { // characteristics
uint16_t desc_count = 1; uint16_t char_count = 1;
esp_gatt_status_t desc_status = esp_ble_gattc_get_all_descr( esp_gatt_status_t char_status =
this->gattc_if_, this->conn_id_, char_result.char_handle, &desc_result, &desc_count, desc_offset); esp_ble_gattc_get_all_char(this->gattc_if_, this->conn_id_, service_result.start_handle,
if (desc_status == ESP_GATT_INVALID_OFFSET || desc_status == ESP_GATT_NOT_FOUND) { service_result.end_handle, &char_result, &char_count, char_offset);
if (char_status == ESP_GATT_INVALID_OFFSET || char_status == ESP_GATT_NOT_FOUND) {
break; break;
} }
if (desc_status != ESP_GATT_OK) { if (char_status != ESP_GATT_OK) {
ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_descr error, status=%d", this->connection_index_, ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_char error, status=%d", this->connection_index_,
this->address_str().c_str(), desc_status); this->address_str().c_str(), char_status);
this->send_service_ = DONE_SENDING_SERVICES;
return; return;
} }
if (desc_count == 0) { if (char_count == 0) {
break; // No more descriptors break;
} }
characteristic_resp.descriptors.emplace_back(); service_resp.characteristics.emplace_back();
auto &descriptor_resp = characteristic_resp.descriptors.back(); auto &characteristic_resp = service_resp.characteristics.back();
fill_128bit_uuid_array(descriptor_resp.uuid, desc_result.uuid); fill_128bit_uuid_array(characteristic_resp.uuid, char_result.uuid);
descriptor_resp.handle = desc_result.handle; characteristic_resp.handle = char_result.char_handle;
desc_offset++; characteristic_resp.properties = char_result.properties;
char_offset++;
// Get the number of descriptors directly with one call
uint16_t total_desc_count = 0;
esp_gatt_status_t desc_count_status = esp_ble_gattc_get_attr_count(
this->gattc_if_, this->conn_id_, ESP_GATT_DB_DESCRIPTOR, 0, 0, char_result.char_handle, &total_desc_count);
if (desc_count_status != ESP_GATT_OK) {
ESP_LOGE(TAG, "[%d] [%s] Error getting descriptor count for char handle %d, status=%d", this->connection_index_,
this->address_str().c_str(), char_result.char_handle, desc_count_status);
this->send_service_ = DONE_SENDING_SERVICES;
return;
}
if (total_desc_count == 0) {
// No descriptors, continue to next characteristic
continue;
}
// Reserve space and process descriptors
characteristic_resp.descriptors.reserve(total_desc_count);
uint16_t desc_offset = 0;
esp_gattc_descr_elem_t desc_result;
while (true) { // descriptors
uint16_t desc_count = 1;
esp_gatt_status_t desc_status = esp_ble_gattc_get_all_descr(
this->gattc_if_, this->conn_id_, char_result.char_handle, &desc_result, &desc_count, desc_offset);
if (desc_status == ESP_GATT_INVALID_OFFSET || desc_status == ESP_GATT_NOT_FOUND) {
break;
}
if (desc_status != ESP_GATT_OK) {
ESP_LOGE(TAG, "[%d] [%s] esp_ble_gattc_get_all_descr error, status=%d", this->connection_index_,
this->address_str().c_str(), desc_status);
this->send_service_ = DONE_SENDING_SERVICES;
return;
}
if (desc_count == 0) {
break; // No more descriptors
}
characteristic_resp.descriptors.emplace_back();
auto &descriptor_resp = characteristic_resp.descriptors.back();
fill_128bit_uuid_array(descriptor_resp.uuid, desc_result.uuid);
descriptor_resp.handle = desc_result.handle;
desc_offset++;
}
} }
} }
// Send the message (we already checked api_conn is not null at the beginning) // Send the message with 1-3 services
api_conn->send_message(resp, api::BluetoothGATTGetServicesResponse::MESSAGE_TYPE); api_conn->send_message(resp, api::BluetoothGATTGetServicesResponse::MESSAGE_TYPE);
} }

1
esphome/components/bluetooth_proxy/bluetooth_proxy.h
View File

@ -22,6 +22,7 @@ namespace esphome::bluetooth_proxy {
static const esp_err_t ESP_GATT_NOT_CONNECTED = -1; static const esp_err_t ESP_GATT_NOT_CONNECTED = -1;
static const int DONE_SENDING_SERVICES = -2; static const int DONE_SENDING_SERVICES = -2;
static const uint8_t MAX_SERVICES_PER_BATCH = 3;
using namespace esp32_ble_client; using namespace esp32_ble_client;