ESPHome  2024.11.1
esp32_ble_tracker.cpp
Go to the documentation of this file.
1 #ifdef USE_ESP32
2 
3 #include "esp32_ble_tracker.h"
5 #include "esphome/core/defines.h"
6 #include "esphome/core/hal.h"
7 #include "esphome/core/helpers.h"
8 #include "esphome/core/log.h"
9 
10 #include <esp_bt.h>
11 #include <esp_bt_defs.h>
12 #include <esp_bt_main.h>
13 #include <esp_gap_ble_api.h>
14 #include <freertos/FreeRTOS.h>
15 #include <freertos/FreeRTOSConfig.h>
16 #include <freertos/task.h>
17 #include <nvs_flash.h>
18 #include <cinttypes>
19 
20 #ifdef USE_OTA
22 #endif
23 
24 #ifdef USE_ARDUINO
25 #include <esp32-hal-bt.h>
26 #endif
27 
28 #define MBEDTLS_AES_ALT
29 #include <aes_alt.h>
30 
31 // bt_trace.h
32 #undef TAG
33 
34 namespace esphome {
35 namespace esp32_ble_tracker {
36 
37 static const char *const TAG = "esp32_ble_tracker";
38 
39 ESP32BLETracker *global_esp32_ble_tracker = nullptr; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
40 
42 
44  if (this->parent_->is_failed()) {
45  this->mark_failed();
46  ESP_LOGE(TAG, "BLE Tracker was marked failed by ESP32BLE");
47  return;
48  }
52 
53  if (this->scan_result_buffer_ == nullptr) {
54  ESP_LOGE(TAG, "Could not allocate buffer for BLE Tracker!");
55  this->mark_failed();
56  }
57 
58  global_esp32_ble_tracker = this;
59  this->scan_result_lock_ = xSemaphoreCreateMutex();
60  this->scan_end_lock_ = xSemaphoreCreateMutex();
61  this->scanner_idle_ = true;
62 
63 #ifdef USE_OTA
65  [this](ota::OTAState state, float progress, uint8_t error, ota::OTAComponent *comp) {
66  if (state == ota::OTA_STARTED) {
67  this->stop_scan();
68  for (auto *client : this->clients_) {
69  client->disconnect();
70  }
71  }
72  });
73 #endif
74 }
75 
77  if (!this->parent_->is_active()) {
78  this->ble_was_disabled_ = true;
79  return;
80  } else if (this->ble_was_disabled_) {
81  this->ble_was_disabled_ = false;
82  // If the BLE stack was disabled, we need to start the scan again.
83  if (this->scan_continuous_) {
84  this->start_scan();
85  }
86  }
87  int connecting = 0;
88  int discovered = 0;
89  int searching = 0;
90  int disconnecting = 0;
91  for (auto *client : this->clients_) {
92  switch (client->state()) {
94  disconnecting++;
95  break;
97  discovered++;
98  break;
100  searching++;
101  break;
104  connecting++;
105  break;
106  default:
107  break;
108  }
109  }
110  bool promote_to_connecting = discovered && !searching && !connecting;
111 
112  if (!this->scanner_idle_) {
113  if (this->scan_result_index_ && // if it looks like we have a scan result we will take the lock
114  xSemaphoreTake(this->scan_result_lock_, 5L / portTICK_PERIOD_MS)) {
115  uint32_t index = this->scan_result_index_;
117  ESP_LOGW(TAG, "Too many BLE events to process. Some devices may not show up.");
118  }
119 
120  if (this->raw_advertisements_) {
121  for (auto *listener : this->listeners_) {
122  listener->parse_devices(this->scan_result_buffer_, this->scan_result_index_);
123  }
124  for (auto *client : this->clients_) {
125  client->parse_devices(this->scan_result_buffer_, this->scan_result_index_);
126  }
127  }
128 
129  if (this->parse_advertisements_) {
130  for (size_t i = 0; i < index; i++) {
131  ESPBTDevice device;
132  device.parse_scan_rst(this->scan_result_buffer_[i]);
133 
134  bool found = false;
135  for (auto *listener : this->listeners_) {
136  if (listener->parse_device(device))
137  found = true;
138  }
139 
140  for (auto *client : this->clients_) {
141  if (client->parse_device(device)) {
142  found = true;
143  if (!connecting && client->state() == ClientState::DISCOVERED) {
144  promote_to_connecting = true;
145  }
146  }
147  }
148 
149  if (!found && !this->scan_continuous_) {
150  this->print_bt_device_info(device);
151  }
152  }
153  }
154  this->scan_result_index_ = 0;
155  xSemaphoreGive(this->scan_result_lock_);
156  }
157 
158  /*
159 
160  Avoid starting the scanner if:
161  - we are already scanning
162  - we are connecting to a device
163  - we are disconnecting from a device
164 
165  Otherwise the scanner could fail to ever start again
166  and our only way to recover is to reboot.
167 
168  https://github.com/espressif/esp-idf/issues/6688
169 
170  */
171  if (!connecting && !disconnecting && xSemaphoreTake(this->scan_end_lock_, 0L)) {
172  if (this->scan_continuous_) {
173  if (!promote_to_connecting && !this->scan_start_failed_ && !this->scan_set_param_failed_) {
174  this->start_scan_(false);
175  } else {
176  // We didn't start the scan, so we need to release the lock
177  xSemaphoreGive(this->scan_end_lock_);
178  }
179  } else if (!this->scanner_idle_) {
180  this->end_of_scan_();
181  return;
182  }
183  }
184 
185  if (this->scan_start_failed_ || this->scan_set_param_failed_) {
186  if (this->scan_start_fail_count_ == 255) {
187  ESP_LOGE(TAG, "ESP-IDF BLE scan could not restart after 255 attempts, rebooting to restore BLE stack...");
188  App.reboot();
189  }
190  if (xSemaphoreTake(this->scan_end_lock_, 0L)) {
191  xSemaphoreGive(this->scan_end_lock_);
192  } else {
193  ESP_LOGD(TAG, "Stopping scan after failure...");
194  this->stop_scan_();
195  }
196  if (this->scan_start_failed_) {
197  ESP_LOGE(TAG, "Scan start failed: %d", this->scan_start_failed_);
198  this->scan_start_failed_ = ESP_BT_STATUS_SUCCESS;
199  }
200  if (this->scan_set_param_failed_) {
201  ESP_LOGE(TAG, "Scan set param failed: %d", this->scan_set_param_failed_);
202  this->scan_set_param_failed_ = ESP_BT_STATUS_SUCCESS;
203  }
204  }
205  }
206 
207  // If there is a discovered client and no connecting
208  // clients and no clients using the scanner to search for
209  // devices, then stop scanning and promote the discovered
210  // client to ready to connect.
211  if (promote_to_connecting) {
212  for (auto *client : this->clients_) {
213  if (client->state() == ClientState::DISCOVERED) {
214  if (xSemaphoreTake(this->scan_end_lock_, 0L)) {
215  // Scanner is not running since we got the
216  // lock, so we can promote the client.
217  xSemaphoreGive(this->scan_end_lock_);
218  // We only want to promote one client at a time.
219  // once the scanner is fully stopped.
220  client->set_state(ClientState::READY_TO_CONNECT);
221  } else {
222  ESP_LOGD(TAG, "Pausing scan to make connection...");
223  this->stop_scan_();
224  }
225  break;
226  }
227  }
228  }
229 }
230 
232  if (xSemaphoreTake(this->scan_end_lock_, 0L)) {
233  this->start_scan_(true);
234  } else {
235  ESP_LOGW(TAG, "Scan requested when a scan is already in progress. Ignoring.");
236  }
237 }
238 
240  ESP_LOGD(TAG, "Stopping scan.");
241  this->scan_continuous_ = false;
242  this->stop_scan_();
243 }
244 
246  this->stop_scan_();
247  xSemaphoreGive(this->scan_end_lock_);
248 }
249 
251  this->cancel_timeout("scan");
252  if (this->scanner_idle_) {
253  return;
254  }
255  esp_err_t err = esp_ble_gap_stop_scanning();
256  if (err != ESP_OK) {
257  ESP_LOGE(TAG, "esp_ble_gap_stop_scanning failed: %d", err);
258  return;
259  }
260 }
261 
263  if (!this->parent_->is_active()) {
264  ESP_LOGW(TAG, "Cannot start scan while ESP32BLE is disabled.");
265  return;
266  }
267  // The lock must be held when calling this function.
268  if (xSemaphoreTake(this->scan_end_lock_, 0L)) {
269  ESP_LOGE(TAG, "start_scan called without holding scan_end_lock_");
270  return;
271  }
272 
273  ESP_LOGD(TAG, "Starting scan...");
274  if (!first) {
275  for (auto *listener : this->listeners_)
276  listener->on_scan_end();
277  }
278  this->already_discovered_.clear();
279  this->scan_params_.scan_type = this->scan_active_ ? BLE_SCAN_TYPE_ACTIVE : BLE_SCAN_TYPE_PASSIVE;
280  this->scan_params_.own_addr_type = BLE_ADDR_TYPE_PUBLIC;
281  this->scan_params_.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL;
282  this->scan_params_.scan_interval = this->scan_interval_;
283  this->scan_params_.scan_window = this->scan_window_;
284 
285  esp_err_t err = esp_ble_gap_set_scan_params(&this->scan_params_);
286  if (err != ESP_OK) {
287  ESP_LOGE(TAG, "esp_ble_gap_set_scan_params failed: %d", err);
288  return;
289  }
290  err = esp_ble_gap_start_scanning(this->scan_duration_);
291  if (err != ESP_OK) {
292  ESP_LOGE(TAG, "esp_ble_gap_start_scanning failed: %d", err);
293  return;
294  }
295  this->scanner_idle_ = false;
296 
297  this->set_timeout("scan", this->scan_duration_ * 2000, []() {
298  ESP_LOGE(TAG, "ESP-IDF BLE scan never terminated, rebooting to restore BLE stack...");
299  App.reboot();
300  });
301 }
302 
304  // The lock must be held when calling this function.
305  if (xSemaphoreTake(this->scan_end_lock_, 0L)) {
306  ESP_LOGE(TAG, "end_of_scan_ called without holding the scan_end_lock_");
307  return;
308  }
309 
310  ESP_LOGD(TAG, "End of scan.");
311  this->scanner_idle_ = true;
312  this->already_discovered_.clear();
313  xSemaphoreGive(this->scan_end_lock_);
314  this->cancel_timeout("scan");
315 
316  for (auto *listener : this->listeners_)
317  listener->on_scan_end();
318 }
319 
321  client->app_id = ++this->app_id_;
322  this->clients_.push_back(client);
324 }
325 
327  listener->set_parent(this);
328  this->listeners_.push_back(listener);
330 }
331 
333  this->raw_advertisements_ = false;
334  this->parse_advertisements_ = false;
335  for (auto *listener : this->listeners_) {
336  if (listener->get_advertisement_parser_type() == AdvertisementParserType::PARSED_ADVERTISEMENTS) {
337  this->parse_advertisements_ = true;
338  } else {
339  this->raw_advertisements_ = true;
340  }
341  }
342  for (auto *client : this->clients_) {
343  if (client->get_advertisement_parser_type() == AdvertisementParserType::PARSED_ADVERTISEMENTS) {
344  this->parse_advertisements_ = true;
345  } else {
346  this->raw_advertisements_ = true;
347  }
348  }
349 }
350 
351 void ESP32BLETracker::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
352  switch (event) {
353  case ESP_GAP_BLE_SCAN_RESULT_EVT:
354  this->gap_scan_result_(param->scan_rst);
355  break;
356  case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
357  this->gap_scan_set_param_complete_(param->scan_param_cmpl);
358  break;
359  case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
360  this->gap_scan_start_complete_(param->scan_start_cmpl);
361  break;
362  case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
363  this->gap_scan_stop_complete_(param->scan_stop_cmpl);
364  break;
365  default:
366  break;
367  }
368  for (auto *client : this->clients_) {
369  client->gap_event_handler(event, param);
370  }
371 }
372 
373 void ESP32BLETracker::gap_scan_set_param_complete_(const esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param &param) {
374  if (param.status == ESP_BT_STATUS_DONE) {
375  this->scan_set_param_failed_ = ESP_BT_STATUS_SUCCESS;
376  } else {
377  this->scan_set_param_failed_ = param.status;
378  }
379 }
380 
381 void ESP32BLETracker::gap_scan_start_complete_(const esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param &param) {
382  this->scan_start_failed_ = param.status;
383  if (param.status == ESP_BT_STATUS_SUCCESS) {
384  this->scan_start_fail_count_ = 0;
385  } else {
386  this->scan_start_fail_count_++;
387  xSemaphoreGive(this->scan_end_lock_);
388  }
389 }
390 
391 void ESP32BLETracker::gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param &param) {
392  xSemaphoreGive(this->scan_end_lock_);
393 }
394 
395 void ESP32BLETracker::gap_scan_result_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
396  if (param.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
397  if (xSemaphoreTake(this->scan_result_lock_, 0L)) {
399  this->scan_result_buffer_[this->scan_result_index_++] = param;
400  }
401  xSemaphoreGive(this->scan_result_lock_);
402  }
403  } else if (param.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
404  xSemaphoreGive(this->scan_end_lock_);
405  }
406 }
407 
408 void ESP32BLETracker::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
409  esp_ble_gattc_cb_param_t *param) {
410  for (auto *client : this->clients_) {
411  client->gattc_event_handler(event, gattc_if, param);
412  }
413 }
414 
415 ESPBLEiBeacon::ESPBLEiBeacon(const uint8_t *data) { memcpy(&this->beacon_data_, data, sizeof(beacon_data_)); }
417  if (!data.uuid.contains(0x4C, 0x00))
418  return {};
419 
420  if (data.data.size() != 23)
421  return {};
422  return ESPBLEiBeacon(data.data.data());
423 }
424 
425 void ESPBTDevice::parse_scan_rst(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
426  this->scan_result_ = param;
427  for (uint8_t i = 0; i < ESP_BD_ADDR_LEN; i++)
428  this->address_[i] = param.bda[i];
429  this->address_type_ = param.ble_addr_type;
430  this->rssi_ = param.rssi;
431  this->parse_adv_(param);
432 
433 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
434  ESP_LOGVV(TAG, "Parse Result:");
435  const char *address_type = "";
436  switch (this->address_type_) {
437  case BLE_ADDR_TYPE_PUBLIC:
438  address_type = "PUBLIC";
439  break;
440  case BLE_ADDR_TYPE_RANDOM:
441  address_type = "RANDOM";
442  break;
443  case BLE_ADDR_TYPE_RPA_PUBLIC:
444  address_type = "RPA_PUBLIC";
445  break;
446  case BLE_ADDR_TYPE_RPA_RANDOM:
447  address_type = "RPA_RANDOM";
448  break;
449  }
450  ESP_LOGVV(TAG, " Address: %02X:%02X:%02X:%02X:%02X:%02X (%s)", this->address_[0], this->address_[1],
451  this->address_[2], this->address_[3], this->address_[4], this->address_[5], address_type);
452 
453  ESP_LOGVV(TAG, " RSSI: %d", this->rssi_);
454  ESP_LOGVV(TAG, " Name: '%s'", this->name_.c_str());
455  for (auto &it : this->tx_powers_) {
456  ESP_LOGVV(TAG, " TX Power: %d", it);
457  }
458  if (this->appearance_.has_value()) {
459  ESP_LOGVV(TAG, " Appearance: %u", *this->appearance_);
460  }
461  if (this->ad_flag_.has_value()) {
462  ESP_LOGVV(TAG, " Ad Flag: %u", *this->ad_flag_);
463  }
464  for (auto &uuid : this->service_uuids_) {
465  ESP_LOGVV(TAG, " Service UUID: %s", uuid.to_string().c_str());
466  }
467  for (auto &data : this->manufacturer_datas_) {
468  auto ibeacon = ESPBLEiBeacon::from_manufacturer_data(data);
469  if (ibeacon.has_value()) {
470  ESP_LOGVV(TAG, " Manufacturer iBeacon:");
471  ESP_LOGVV(TAG, " UUID: %s", ibeacon.value().get_uuid().to_string().c_str());
472  ESP_LOGVV(TAG, " Major: %u", ibeacon.value().get_major());
473  ESP_LOGVV(TAG, " Minor: %u", ibeacon.value().get_minor());
474  ESP_LOGVV(TAG, " TXPower: %d", ibeacon.value().get_signal_power());
475  } else {
476  ESP_LOGVV(TAG, " Manufacturer ID: %s, data: %s", data.uuid.to_string().c_str(),
477  format_hex_pretty(data.data).c_str());
478  }
479  }
480  for (auto &data : this->service_datas_) {
481  ESP_LOGVV(TAG, " Service data:");
482  ESP_LOGVV(TAG, " UUID: %s", data.uuid.to_string().c_str());
483  ESP_LOGVV(TAG, " Data: %s", format_hex_pretty(data.data).c_str());
484  }
485 
486  ESP_LOGVV(TAG, " Adv data: %s", format_hex_pretty(param.ble_adv, param.adv_data_len + param.scan_rsp_len).c_str());
487 #endif
488 }
489 void ESPBTDevice::parse_adv_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param) {
490  size_t offset = 0;
491  const uint8_t *payload = param.ble_adv;
492  uint8_t len = param.adv_data_len + param.scan_rsp_len;
493 
494  while (offset + 2 < len) {
495  const uint8_t field_length = payload[offset++]; // First byte is length of adv record
496  if (field_length == 0) {
497  continue; // Possible zero padded advertisement data
498  }
499 
500  // first byte of adv record is adv record type
501  const uint8_t record_type = payload[offset++];
502  const uint8_t *record = &payload[offset];
503  const uint8_t record_length = field_length - 1;
504  offset += record_length;
505 
506  // See also Generic Access Profile Assigned Numbers:
507  // https://www.bluetooth.com/specifications/assigned-numbers/generic-access-profile/ See also ADVERTISING AND SCAN
508  // RESPONSE DATA FORMAT: https://www.bluetooth.com/specifications/bluetooth-core-specification/ (vol 3, part C, 11)
509  // See also Core Specification Supplement: https://www.bluetooth.com/specifications/bluetooth-core-specification/
510  // (called CSS here)
511 
512  switch (record_type) {
513  case ESP_BLE_AD_TYPE_NAME_SHORT:
514  case ESP_BLE_AD_TYPE_NAME_CMPL: {
515  // CSS 1.2 LOCAL NAME
516  // "The Local Name data type shall be the same as, or a shortened version of, the local name assigned to the
517  // device." CSS 1: Optional in this context; shall not appear more than once in a block.
518  // SHORTENED LOCAL NAME
519  // "The Shortened Local Name data type defines a shortened version of the Local Name data type. The Shortened
520  // Local Name data type shall not be used to advertise a name that is longer than the Local Name data type."
521  if (record_length > this->name_.length()) {
522  this->name_ = std::string(reinterpret_cast<const char *>(record), record_length);
523  }
524  break;
525  }
526  case ESP_BLE_AD_TYPE_TX_PWR: {
527  // CSS 1.5 TX POWER LEVEL
528  // "The TX Power Level data type indicates the transmitted power level of the packet containing the data type."
529  // CSS 1: Optional in this context (may appear more than once in a block).
530  this->tx_powers_.push_back(*payload);
531  break;
532  }
533  case ESP_BLE_AD_TYPE_APPEARANCE: {
534  // CSS 1.12 APPEARANCE
535  // "The Appearance data type defines the external appearance of the device."
536  // See also https://www.bluetooth.com/specifications/gatt/characteristics/
537  // CSS 1: Optional in this context; shall not appear more than once in a block and shall not appear in both
538  // the AD and SRD of the same extended advertising interval.
539  this->appearance_ = *reinterpret_cast<const uint16_t *>(record);
540  break;
541  }
542  case ESP_BLE_AD_TYPE_FLAG: {
543  // CSS 1.3 FLAGS
544  // "The Flags data type contains one bit Boolean flags. The Flags data type shall be included when any of the
545  // Flag bits are non-zero and the advertising packet is connectable, otherwise the Flags data type may be
546  // omitted."
547  // CSS 1: Optional in this context; shall not appear more than once in a block.
548  this->ad_flag_ = *record;
549  break;
550  }
551  // CSS 1.1 SERVICE UUID
552  // The Service UUID data type is used to include a list of Service or Service Class UUIDs.
553  // There are six data types defined for the three sizes of Service UUIDs that may be returned:
554  // CSS 1: Optional in this context (may appear more than once in a block).
555  case ESP_BLE_AD_TYPE_16SRV_CMPL:
556  case ESP_BLE_AD_TYPE_16SRV_PART: {
557  // • 16-bit Bluetooth Service UUIDs
558  for (uint8_t i = 0; i < record_length / 2; i++) {
559  this->service_uuids_.push_back(ESPBTUUID::from_uint16(*reinterpret_cast<const uint16_t *>(record + 2 * i)));
560  }
561  break;
562  }
563  case ESP_BLE_AD_TYPE_32SRV_CMPL:
564  case ESP_BLE_AD_TYPE_32SRV_PART: {
565  // • 32-bit Bluetooth Service UUIDs
566  for (uint8_t i = 0; i < record_length / 4; i++) {
567  this->service_uuids_.push_back(ESPBTUUID::from_uint32(*reinterpret_cast<const uint32_t *>(record + 4 * i)));
568  }
569  break;
570  }
571  case ESP_BLE_AD_TYPE_128SRV_CMPL:
572  case ESP_BLE_AD_TYPE_128SRV_PART: {
573  // • Global 128-bit Service UUIDs
574  this->service_uuids_.push_back(ESPBTUUID::from_raw(record));
575  break;
576  }
577  case ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE: {
578  // CSS 1.4 MANUFACTURER SPECIFIC DATA
579  // "The Manufacturer Specific data type is used for manufacturer specific data. The first two data octets shall
580  // contain a company identifier from Assigned Numbers. The interpretation of any other octets within the data
581  // shall be defined by the manufacturer specified by the company identifier."
582  // CSS 1: Optional in this context (may appear more than once in a block).
583  if (record_length < 2) {
584  ESP_LOGV(TAG, "Record length too small for ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE");
585  break;
586  }
587  ServiceData data{};
588  data.uuid = ESPBTUUID::from_uint16(*reinterpret_cast<const uint16_t *>(record));
589  data.data.assign(record + 2UL, record + record_length);
590  this->manufacturer_datas_.push_back(data);
591  break;
592  }
593 
594  // CSS 1.11 SERVICE DATA
595  // "The Service Data data type consists of a service UUID with the data associated with that service."
596  // CSS 1: Optional in this context (may appear more than once in a block).
597  case ESP_BLE_AD_TYPE_SERVICE_DATA: {
598  // «Service Data - 16 bit UUID»
599  // Size: 2 or more octets
600  // The first 2 octets contain the 16 bit Service UUID fol- lowed by additional service data
601  if (record_length < 2) {
602  ESP_LOGV(TAG, "Record length too small for ESP_BLE_AD_TYPE_SERVICE_DATA");
603  break;
604  }
605  ServiceData data{};
606  data.uuid = ESPBTUUID::from_uint16(*reinterpret_cast<const uint16_t *>(record));
607  data.data.assign(record + 2UL, record + record_length);
608  this->service_datas_.push_back(data);
609  break;
610  }
611  case ESP_BLE_AD_TYPE_32SERVICE_DATA: {
612  // «Service Data - 32 bit UUID»
613  // Size: 4 or more octets
614  // The first 4 octets contain the 32 bit Service UUID fol- lowed by additional service data
615  if (record_length < 4) {
616  ESP_LOGV(TAG, "Record length too small for ESP_BLE_AD_TYPE_32SERVICE_DATA");
617  break;
618  }
619  ServiceData data{};
620  data.uuid = ESPBTUUID::from_uint32(*reinterpret_cast<const uint32_t *>(record));
621  data.data.assign(record + 4UL, record + record_length);
622  this->service_datas_.push_back(data);
623  break;
624  }
625  case ESP_BLE_AD_TYPE_128SERVICE_DATA: {
626  // «Service Data - 128 bit UUID»
627  // Size: 16 or more octets
628  // The first 16 octets contain the 128 bit Service UUID followed by additional service data
629  if (record_length < 16) {
630  ESP_LOGV(TAG, "Record length too small for ESP_BLE_AD_TYPE_128SERVICE_DATA");
631  break;
632  }
633  ServiceData data{};
634  data.uuid = ESPBTUUID::from_raw(record);
635  data.data.assign(record + 16UL, record + record_length);
636  this->service_datas_.push_back(data);
637  break;
638  }
639  case ESP_BLE_AD_TYPE_INT_RANGE:
640  // Avoid logging this as it's very verbose
641  break;
642  default: {
643  ESP_LOGV(TAG, "Unhandled type: advType: 0x%02x", record_type);
644  break;
645  }
646  }
647  }
648 }
649 std::string ESPBTDevice::address_str() const {
650  char mac[24];
651  snprintf(mac, sizeof(mac), "%02X:%02X:%02X:%02X:%02X:%02X", this->address_[0], this->address_[1], this->address_[2],
652  this->address_[3], this->address_[4], this->address_[5]);
653  return mac;
654 }
655 uint64_t ESPBTDevice::address_uint64() const { return esp32_ble::ble_addr_to_uint64(this->address_); }
656 
658  ESP_LOGCONFIG(TAG, "BLE Tracker:");
659  ESP_LOGCONFIG(TAG, " Scan Duration: %" PRIu32 " s", this->scan_duration_);
660  ESP_LOGCONFIG(TAG, " Scan Interval: %.1f ms", this->scan_interval_ * 0.625f);
661  ESP_LOGCONFIG(TAG, " Scan Window: %.1f ms", this->scan_window_ * 0.625f);
662  ESP_LOGCONFIG(TAG, " Scan Type: %s", this->scan_active_ ? "ACTIVE" : "PASSIVE");
663  ESP_LOGCONFIG(TAG, " Continuous Scanning: %s", this->scan_continuous_ ? "True" : "False");
664 }
665 
667  const uint64_t address = device.address_uint64();
668  for (auto &disc : this->already_discovered_) {
669  if (disc == address)
670  return;
671  }
672  this->already_discovered_.push_back(address);
673 
674  ESP_LOGD(TAG, "Found device %s RSSI=%d", device.address_str().c_str(), device.get_rssi());
675 
676  const char *address_type_s;
677  switch (device.get_address_type()) {
678  case BLE_ADDR_TYPE_PUBLIC:
679  address_type_s = "PUBLIC";
680  break;
681  case BLE_ADDR_TYPE_RANDOM:
682  address_type_s = "RANDOM";
683  break;
684  case BLE_ADDR_TYPE_RPA_PUBLIC:
685  address_type_s = "RPA_PUBLIC";
686  break;
687  case BLE_ADDR_TYPE_RPA_RANDOM:
688  address_type_s = "RPA_RANDOM";
689  break;
690  default:
691  address_type_s = "UNKNOWN";
692  break;
693  }
694 
695  ESP_LOGD(TAG, " Address Type: %s", address_type_s);
696  if (!device.get_name().empty()) {
697  ESP_LOGD(TAG, " Name: '%s'", device.get_name().c_str());
698  }
699  for (auto &tx_power : device.get_tx_powers()) {
700  ESP_LOGD(TAG, " TX Power: %d", tx_power);
701  }
702 }
703 
704 bool ESPBTDevice::resolve_irk(const uint8_t *irk) const {
705  uint8_t ecb_key[16];
706  uint8_t ecb_plaintext[16];
707  uint8_t ecb_ciphertext[16];
708 
709  uint64_t addr64 = esp32_ble::ble_addr_to_uint64(this->address_);
710 
711  memcpy(&ecb_key, irk, 16);
712  memset(&ecb_plaintext, 0, 16);
713 
714  ecb_plaintext[13] = (addr64 >> 40) & 0xff;
715  ecb_plaintext[14] = (addr64 >> 32) & 0xff;
716  ecb_plaintext[15] = (addr64 >> 24) & 0xff;
717 
718  mbedtls_aes_context ctx = {0, 0, {0}};
719  mbedtls_aes_init(&ctx);
720 
721  if (mbedtls_aes_setkey_enc(&ctx, ecb_key, 128) != 0) {
722  mbedtls_aes_free(&ctx);
723  return false;
724  }
725 
726  if (mbedtls_aes_crypt_ecb(&ctx, ESP_AES_ENCRYPT, ecb_plaintext, ecb_ciphertext) != 0) {
727  mbedtls_aes_free(&ctx);
728  return false;
729  }
730 
731  mbedtls_aes_free(&ctx);
732 
733  return ecb_ciphertext[15] == (addr64 & 0xff) && ecb_ciphertext[14] == ((addr64 >> 8) & 0xff) &&
734  ecb_ciphertext[13] == ((addr64 >> 16) & 0xff);
735 }
736 
737 } // namespace esp32_ble_tracker
738 } // namespace esphome
739 
740 #endif
void end_of_scan_()
Called when a scan ends.
uint64_t ble_addr_to_uint64(const esp_bd_addr_t address)
Definition: ble.cpp:400
std::string format_hex_pretty(const uint8_t *data, size_t length)
Format the byte array data of length len in pretty-printed, human-readable hex.
Definition: helpers.cpp:364
bool cancel_timeout(const std::string &name)
Cancel a timeout function.
Definition: component.cpp:73
void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) override
void setup() override
Setup the FreeRTOS task and the Bluetooth stack.
void register_listener(ESPBTDeviceListener *listener)
void start_scan_(bool first)
Start a single scan by setting up the parameters and doing some esp-idf calls.
void set_timeout(const std::string &name, uint32_t timeout, std::function< void()> &&f)
Set a timeout function with a unique name.
Definition: component.cpp:69
void parse_scan_rst(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param)
T * allocate(size_t n)
Definition: helpers.h:681
const std::vector< int8_t > & get_tx_powers() const
const float AFTER_BLUETOOTH
Definition: component.cpp:22
esp_ble_scan_params_t scan_params_
A structure holding the ESP BLE scan parameters.
ESP32BLETracker * global_esp32_ble_tracker
static ESPBTUUID from_uint32(uint32_t uuid)
Definition: ble_uuid.cpp:22
esp_ble_gap_cb_param_t::ble_scan_result_evt_param * scan_result_buffer_
static ESPBTUUID from_uint16(uint16_t uuid)
Definition: ble_uuid.cpp:16
Application App
Global storage of Application pointer - only one Application can exist.
void add_on_state_callback(std::function< void(OTAState, float, uint8_t, OTAComponent *)> &&callback)
Definition: ota_backend.h:82
bool resolve_irk(const uint8_t *irk) const
esp_ble_addr_type_t get_address_type() const
void gap_scan_set_param_complete_(const esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param &param)
Called when a ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT event is received.
uint32_t scan_duration_
The interval in seconds to perform scans.
std::string size_t len
Definition: helpers.h:293
std::vector< uint64_t > already_discovered_
Vector of addresses that have already been printed in print_bt_device_info.
virtual void mark_failed()
Mark this component as failed.
Definition: component.cpp:118
bool contains(uint8_t data1, uint8_t data2) const
Definition: ble_uuid.cpp:126
void gap_scan_result_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param)
Called when a ESP_GAP_BLE_SCAN_RESULT_EVT event is received.
Implementation of SPI Controller mode.
Definition: a01nyub.cpp:7
uint8_t address
Definition: bl0906.h:211
static ESPBTUUID from_raw(const uint8_t *data)
Definition: ble_uuid.cpp:28
void print_bt_device_info(const ESPBTDevice &device)
const std::string & get_name() const
An STL allocator that uses SPI or internal RAM.
Definition: helpers.h:666
OTAGlobalCallback * get_global_ota_callback()
Definition: ota_backend.cpp:9
void gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param &param)
Called when a ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT event is received.
static optional< ESPBLEiBeacon > from_manufacturer_data(const ServiceData &data)
void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) override
std::vector< ESPBTDeviceListener * > listeners_
std::vector< ESPBTClient * > clients_
Client parameters.
void parse_adv_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param &param)
void gap_scan_start_complete_(const esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param &param)
Called when a ESP_GAP_BLE_SCAN_START_COMPLETE_EVT event is received.
bool state
Definition: fan.h:34