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