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>
24#ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
25#include <esp_coexist.h>
29#include <esp32-hal-bt.h>
32#define MBEDTLS_AES_ALT
39namespace esp32_ble_tracker {
41static const char *
const TAG =
"esp32_ble_tracker";
48 if (this->
parent_->is_failed()) {
50 ESP_LOGE(TAG,
"BLE Tracker was marked failed by ESP32BLE");
57 ESP_LOGE(TAG,
"Could not allocate ring buffer for BLE Tracker!");
61 global_esp32_ble_tracker =
this;
68 for (
auto *client : this->
clients_) {
77 if (!this->
parent_->is_active()) {
90 int disconnecting = 0;
91 for (
auto *client : this->
clients_) {
92 switch (client->state()) {
116 ESP_LOGD(TAG,
"connecting: %d, discovered: %d, searching: %d, disconnecting: %d",
connecting_,
discovered_,
119 bool promote_to_connecting = discovered && !searching && !connecting;
130 while (read_idx != write_idx) {
136 listener->parse_devices(&scan_result, 1);
138 for (
auto *client : this->clients_) {
139 client->parse_devices(&scan_result, 1);
149 if (listener->parse_device(device))
153 for (
auto *client : this->clients_) {
154 if (client->parse_device(device)) {
157 promote_to_connecting =
true;
168 read_idx = (read_idx + 1) % SCAN_RESULT_BUFFER_SIZE;
177 ESP_LOGW(TAG,
"Dropped %zu BLE scan results due to buffer overflow", dropped);
187 ESP_LOGE(TAG,
"Scan could not restart after %d attempts, rebooting to restore stack (IDF)",
188 std::numeric_limits<uint8_t>::max());
214#ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
217 ESP_LOGD(TAG,
"Setting coexistence preference to balanced.");
218 esp_coex_preference_set(ESP_COEX_PREFER_BALANCE);
229 if (promote_to_connecting &&
231 for (
auto *client : this->clients_) {
234 ESP_LOGD(TAG,
"Stopping scan to make connection");
237 ESP_LOGD(TAG,
"Promoting client to connect");
240#ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
241 ESP_LOGD(TAG,
"Setting coexistence to Bluetooth to make connection.");
244 esp_coex_preference_set(ESP_COEX_PREFER_BT);
258 ESP_LOGD(TAG,
"Stopping scan.");
268 ESP_LOGE(TAG,
"Scan is already stopped while trying to stop.");
270 ESP_LOGE(TAG,
"Scan is starting while trying to stop.");
272 ESP_LOGE(TAG,
"Scan is already stopping while trying to stop.");
274 ESP_LOGE(TAG,
"Scan is already stopped while trying to stop.");
280 esp_err_t err = esp_ble_gap_stop_scanning();
282 ESP_LOGE(TAG,
"esp_ble_gap_stop_scanning failed: %d", err);
288 if (!this->
parent_->is_active()) {
289 ESP_LOGW(TAG,
"Cannot start scan while ESP32BLE is disabled.");
294 ESP_LOGE(TAG,
"Cannot start scan while already starting.");
296 ESP_LOGE(TAG,
"Cannot start scan while already running.");
298 ESP_LOGE(TAG,
"Cannot start scan while already stopping.");
300 ESP_LOGE(TAG,
"Cannot start scan while already failed.");
302 ESP_LOGE(TAG,
"Cannot start scan while already stopped.");
307 ESP_LOGD(TAG,
"Starting scan, set scanner state to STARTING.");
310 listener->on_scan_end();
314 this->
scan_params_.own_addr_type = BLE_ADDR_TYPE_PUBLIC;
315 this->
scan_params_.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL;
321 ESP_LOGE(TAG,
"Scan never terminated, rebooting to restore stack (IDF)");
325 esp_err_t err = esp_ble_gap_set_scan_params(&this->
scan_params_);
327 ESP_LOGE(TAG,
"esp_ble_gap_set_scan_params failed: %d", err);
332 ESP_LOGE(TAG,
"esp_ble_gap_start_scanning failed: %d", err);
340 ESP_LOGE(TAG,
"end_of_scan_ called while scanner is not stopped.");
343 ESP_LOGD(TAG,
"End of scan, set scanner state to IDLE.");
348 listener->on_scan_end();
374 for (
auto *client : this->
clients_) {
385 case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
388 case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
391 case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
398 for (
auto *client : this->
clients_) {
399 client->gap_event_handler(event, param);
404 ESP_LOGV(TAG,
"gap_scan_result - event %d", scan_result.search_evt);
406 if (scan_result.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
413 size_t next_write_idx = (write_idx + 1) % SCAN_RESULT_BUFFER_SIZE;
419 if (next_write_idx != read_idx) {
429 }
else if (scan_result.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
433 ESP_LOGE(TAG,
"Scan was not running when scan completed.");
435 ESP_LOGE(TAG,
"Scan was not started when scan completed.");
437 ESP_LOGE(TAG,
"Scan was in failed state when scan completed.");
439 ESP_LOGE(TAG,
"Scan was idle when scan completed.");
441 ESP_LOGE(TAG,
"Scan was stopped when scan completed.");
449 ESP_LOGV(TAG,
"gap_scan_set_param_complete - status %d", param.status);
450 if (param.status == ESP_BT_STATUS_DONE) {
458 ESP_LOGV(TAG,
"gap_scan_start_complete - status %d", param.status);
462 ESP_LOGE(TAG,
"Scan was already running when start complete.");
464 ESP_LOGE(TAG,
"Scan was stopping when start complete.");
466 ESP_LOGE(TAG,
"Scan was in failed state when start complete.");
468 ESP_LOGE(TAG,
"Scan was idle when start complete.");
470 ESP_LOGE(TAG,
"Scan was stopped when start complete.");
473 if (param.status == ESP_BT_STATUS_SUCCESS) {
485 ESP_LOGV(TAG,
"gap_scan_stop_complete - status %d", param.status);
488 ESP_LOGE(TAG,
"Scan was not running when stop complete.");
490 ESP_LOGE(TAG,
"Scan was not started when stop complete.");
492 ESP_LOGE(TAG,
"Scan was in failed state when stop complete.");
494 ESP_LOGE(TAG,
"Scan was idle when stop complete.");
496 ESP_LOGE(TAG,
"Scan was stopped when stop complete.");
503 esp_ble_gattc_cb_param_t *param) {
504 for (
auto *client : this->
clients_) {
505 client->gattc_event_handler(event, gattc_if, param);
519 if (data.
data.size() != 23)
525 for (uint8_t i = 0; i < ESP_BD_ADDR_LEN; i++)
526 this->
address_[i] = scan_result.bda[i];
527 this->
address_type_ =
static_cast<esp_ble_addr_type_t
>(scan_result.ble_addr_type);
528 this->
rssi_ = scan_result.rssi;
531 uint8_t total_len = scan_result.adv_data_len + scan_result.scan_rsp_len;
532 this->
parse_adv_(scan_result.ble_adv, total_len);
534#ifdef ESPHOME_LOG_HAS_VERY_VERBOSE
535 ESP_LOGVV(TAG,
"Parse Result:");
536 const char *address_type;
538 case BLE_ADDR_TYPE_PUBLIC:
539 address_type =
"PUBLIC";
541 case BLE_ADDR_TYPE_RANDOM:
542 address_type =
"RANDOM";
544 case BLE_ADDR_TYPE_RPA_PUBLIC:
545 address_type =
"RPA_PUBLIC";
547 case BLE_ADDR_TYPE_RPA_RANDOM:
548 address_type =
"RPA_RANDOM";
551 address_type =
"UNKNOWN";
554 ESP_LOGVV(TAG,
" Address: %02X:%02X:%02X:%02X:%02X:%02X (%s)", this->
address_[0], this->
address_[1],
557 ESP_LOGVV(TAG,
" RSSI: %d", this->
rssi_);
558 ESP_LOGVV(TAG,
" Name: '%s'", this->
name_.c_str());
560 ESP_LOGVV(TAG,
" TX Power: %d", it);
563 ESP_LOGVV(TAG,
" Appearance: %u", *this->
appearance_);
566 ESP_LOGVV(TAG,
" Ad Flag: %u", *this->
ad_flag_);
569 ESP_LOGVV(TAG,
" Service UUID: %s", uuid.to_string().c_str());
573 if (ibeacon.has_value()) {
574 ESP_LOGVV(TAG,
" Manufacturer iBeacon:");
575 ESP_LOGVV(TAG,
" UUID: %s", ibeacon.value().get_uuid().to_string().c_str());
576 ESP_LOGVV(TAG,
" Major: %u", ibeacon.value().get_major());
577 ESP_LOGVV(TAG,
" Minor: %u", ibeacon.value().get_minor());
578 ESP_LOGVV(TAG,
" TXPower: %d", ibeacon.value().get_signal_power());
580 ESP_LOGVV(TAG,
" Manufacturer ID: %s, data: %s", data.uuid.to_string().c_str(),
585 ESP_LOGVV(TAG,
" Service data:");
586 ESP_LOGVV(TAG,
" UUID: %s", data.uuid.to_string().c_str());
590 ESP_LOGVV(TAG,
" Adv data: %s",
591 format_hex_pretty(scan_result.ble_adv, scan_result.adv_data_len + scan_result.scan_rsp_len).c_str());
598 while (offset + 2 <
len) {
599 const uint8_t field_length = payload[offset++];
600 if (field_length == 0) {
605 const uint8_t record_type = payload[offset++];
606 const uint8_t *record = &payload[offset];
607 const uint8_t record_length = field_length - 1;
608 offset += record_length;
616 switch (record_type) {
617 case ESP_BLE_AD_TYPE_NAME_SHORT:
618 case ESP_BLE_AD_TYPE_NAME_CMPL: {
625 if (record_length > this->
name_.length()) {
626 this->
name_ = std::string(
reinterpret_cast<const char *
>(record), record_length);
630 case ESP_BLE_AD_TYPE_TX_PWR: {
637 case ESP_BLE_AD_TYPE_APPEARANCE: {
643 this->
appearance_ = *
reinterpret_cast<const uint16_t *
>(record);
646 case ESP_BLE_AD_TYPE_FLAG: {
659 case ESP_BLE_AD_TYPE_16SRV_CMPL:
660 case ESP_BLE_AD_TYPE_16SRV_PART: {
662 for (uint8_t i = 0; i < record_length / 2; i++) {
667 case ESP_BLE_AD_TYPE_32SRV_CMPL:
668 case ESP_BLE_AD_TYPE_32SRV_PART: {
670 for (uint8_t i = 0; i < record_length / 4; i++) {
675 case ESP_BLE_AD_TYPE_128SRV_CMPL:
676 case ESP_BLE_AD_TYPE_128SRV_PART: {
681 case ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE: {
687 if (record_length < 2) {
688 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE");
693 data.data.assign(record + 2UL, record + record_length);
701 case ESP_BLE_AD_TYPE_SERVICE_DATA: {
705 if (record_length < 2) {
706 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_SERVICE_DATA");
711 data.data.assign(record + 2UL, record + record_length);
715 case ESP_BLE_AD_TYPE_32SERVICE_DATA: {
719 if (record_length < 4) {
720 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_32SERVICE_DATA");
725 data.data.assign(record + 4UL, record + record_length);
729 case ESP_BLE_AD_TYPE_128SERVICE_DATA: {
733 if (record_length < 16) {
734 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_128SERVICE_DATA");
739 data.data.assign(record + 16UL, record + record_length);
743 case ESP_BLE_AD_TYPE_INT_RANGE:
747 ESP_LOGV(TAG,
"Unhandled type: advType: 0x%02x", record_type);
755 snprintf(mac,
sizeof(mac),
"%02X:%02X:%02X:%02X:%02X:%02X", this->
address_[0], this->
address_[1], this->
address_[2],
762 ESP_LOGCONFIG(TAG,
"BLE Tracker:");
764 " Scan Duration: %" PRIu32
" s\n"
765 " Scan Interval: %.1f ms\n"
766 " Scan Window: %.1f ms\n"
768 " Continuous Scanning: %s",
773 ESP_LOGCONFIG(TAG,
" Scanner State: IDLE");
776 ESP_LOGCONFIG(TAG,
" Scanner State: STARTING");
779 ESP_LOGCONFIG(TAG,
" Scanner State: RUNNING");
782 ESP_LOGCONFIG(TAG,
" Scanner State: STOPPING");
785 ESP_LOGCONFIG(TAG,
" Scanner State: STOPPED");
788 ESP_LOGCONFIG(TAG,
" Scanner State: FAILED");
791 ESP_LOGCONFIG(TAG,
" Connecting: %d, discovered: %d, searching: %d, disconnecting: %d",
connecting_,
discovered_,
804 this->already_discovered_.push_back(
address);
808 const char *address_type_s;
810 case BLE_ADDR_TYPE_PUBLIC:
811 address_type_s =
"PUBLIC";
813 case BLE_ADDR_TYPE_RANDOM:
814 address_type_s =
"RANDOM";
816 case BLE_ADDR_TYPE_RPA_PUBLIC:
817 address_type_s =
"RPA_PUBLIC";
819 case BLE_ADDR_TYPE_RPA_RANDOM:
820 address_type_s =
"RPA_RANDOM";
823 address_type_s =
"UNKNOWN";
827 ESP_LOGD(TAG,
" Address Type: %s", address_type_s);
829 ESP_LOGD(TAG,
" Name: '%s'", device.
get_name().c_str());
832 ESP_LOGD(TAG,
" TX Power: %d", tx_power);
838 uint8_t ecb_plaintext[16];
839 uint8_t ecb_ciphertext[16];
843 memcpy(&ecb_key, irk, 16);
844 memset(&ecb_plaintext, 0, 16);
846 ecb_plaintext[13] = (addr64 >> 40) & 0xff;
847 ecb_plaintext[14] = (addr64 >> 32) & 0xff;
848 ecb_plaintext[15] = (addr64 >> 24) & 0xff;
850 mbedtls_aes_context ctx = {0, 0, {0}};
851 mbedtls_aes_init(&ctx);
853 if (mbedtls_aes_setkey_enc(&ctx, ecb_key, 128) != 0) {
854 mbedtls_aes_free(&ctx);
858 if (mbedtls_aes_crypt_ecb(&ctx, ESP_AES_ENCRYPT, ecb_plaintext, ecb_ciphertext) != 0) {
859 mbedtls_aes_free(&ctx);
863 mbedtls_aes_free(&ctx);
865 return ecb_ciphertext[15] == (addr64 & 0xff) && ecb_ciphertext[14] == ((addr64 >> 8) & 0xff) &&
866 ecb_ciphertext[13] == ((addr64 >> 16) & 0xff);
virtual void mark_failed()
Mark this component as failed.
bool cancel_timeout(const std::string &name)
Cancel a timeout function.
void set_timeout(const std::string &name, uint32_t timeout, std::function< void()> &&f)
Set a timeout function with a unique name.
An STL allocator that uses SPI or internal RAM.
static ESPBTUUID from_uint32(uint32_t uuid)
static ESPBTUUID from_uint16(uint16_t uuid)
static ESPBTUUID from_raw(const uint8_t *data)
bool contains(uint8_t data1, uint8_t data2) const
std::vector< uint64_t > already_discovered_
Vector of addresses that have already been printed in print_bt_device_info.
uint8_t scan_start_fail_count_
void gap_scan_stop_complete_(const esp_ble_gap_cb_param_t::ble_scan_stop_cmpl_evt_param ¶m)
Called when a ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT event is received.
void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) override
float get_setup_priority() const override
void register_client(ESPBTClient *client)
bool parse_advertisements_
void dump_config() override
void recalculate_advertisement_parser_types()
ScannerState scanner_state_
esp_ble_scan_params_t scan_params_
A structure holding the ESP BLE scan parameters.
void register_listener(ESPBTDeviceListener *listener)
std::atomic< size_t > ring_read_index_
void end_of_scan_()
Called when a scan ends.
CallbackManager< void(ScannerState)> scanner_state_callbacks_
void gap_scan_set_param_complete_(const esp_ble_gap_cb_param_t::ble_scan_param_cmpl_evt_param ¶m)
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::atomic< size_t > scan_results_dropped_
std::atomic< size_t > ring_write_index_
void setup() override
Setup the FreeRTOS task and the Bluetooth stack.
BLEScanResult * scan_ring_buffer_
esp_bt_status_t scan_start_failed_
esp_bt_status_t scan_set_param_failed_
void ble_before_disabled_event_handler() override
void set_scanner_state_(ScannerState state)
Called to set the scanner state. Will also call callbacks to let listeners know when state is changed...
void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) override
void print_bt_device_info(const ESPBTDevice &device)
void gap_scan_event_handler(const BLEScanResult &scan_result) override
void gap_scan_start_complete_(const esp_ble_gap_cb_param_t::ble_scan_start_cmpl_evt_param ¶m)
Called when a ESP_GAP_BLE_SCAN_START_COMPLETE_EVT event is received.
std::vector< ESPBTClient * > clients_
Client parameters.
std::vector< ESPBTDeviceListener * > listeners_
void start_scan_(bool first)
Start a single scan by setting up the parameters and doing some esp-idf calls.
static optional< ESPBLEiBeacon > from_manufacturer_data(const ServiceData &data)
struct esphome::esp32_ble_tracker::ESPBLEiBeacon::@81 beacon_data_
uint64_t address_uint64() const
esp_ble_addr_type_t get_address_type() const
esp_ble_addr_type_t address_type_
optional< uint16_t > appearance_
void parse_adv_(const uint8_t *payload, uint8_t len)
void parse_scan_rst(const BLEScanResult &scan_result)
optional< uint8_t > ad_flag_
std::vector< ServiceData > manufacturer_datas_
std::vector< ESPBTUUID > service_uuids_
const std::vector< int8_t > & get_tx_powers() const
const std::string & get_name() const
std::string address_str() const
bool resolve_irk(const uint8_t *irk) const
std::vector< int8_t > tx_powers_
std::vector< ServiceData > service_datas_
void set_parent(ESP32BLETracker *parent)
void add_on_state_callback(std::function< void(OTAState, float, uint8_t, OTAComponent *)> &&callback)
ESP32BLETracker * global_esp32_ble_tracker
uint64_t ble_addr_to_uint64(const esp_bd_addr_t address)
OTAGlobalCallback * get_global_ota_callback()
const float AFTER_BLUETOOTH
Providing packet encoding functions for exchanging data with a remote host.
Application App
Global storage of Application pointer - only one Application can exist.
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.