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> 25 #include <esp32-hal-bt.h> 28 #define MBEDTLS_AES_ALT 35 namespace esp32_ble_tracker {
37 static const char *
const TAG =
"esp32_ble_tracker";
44 if (this->
parent_->is_failed()) {
46 ESP_LOGE(TAG,
"BLE Tracker was marked failed by ESP32BLE");
54 ESP_LOGE(TAG,
"Could not allocate buffer for BLE Tracker!");
58 global_esp32_ble_tracker =
this;
74 if (!this->
parent_->is_active()) {
87 int disconnecting = 0;
88 for (
auto *client : this->
clients_) {
89 switch (client->state()) {
107 bool promote_to_connecting = discovered && !searching && !connecting;
114 ESP_LOGW(TAG,
"Too many BLE events to process. Some devices may not show up.");
121 for (
auto *client : this->clients_) {
127 for (
size_t i = 0; i < index; i++) {
133 if (listener->parse_device(device))
137 for (
auto *client : this->clients_) {
138 if (client->parse_device(device)) {
141 promote_to_connecting =
true;
168 if (!connecting && !disconnecting && xSemaphoreTake(this->
scan_end_lock_, 0L)) {
184 ESP_LOGE(TAG,
"ESP-IDF BLE scan could not restart after 255 attempts, rebooting to restore BLE stack...");
190 ESP_LOGD(TAG,
"Stopping scan after failure...");
208 if (promote_to_connecting) {
209 for (
auto *client : this->clients_) {
219 ESP_LOGD(TAG,
"Pausing scan to make connection...");
232 ESP_LOGW(TAG,
"Scan requested when a scan is already in progress. Ignoring.");
237 ESP_LOGD(TAG,
"Stopping scan.");
252 esp_err_t err = esp_ble_gap_stop_scanning();
254 ESP_LOGE(TAG,
"esp_ble_gap_stop_scanning failed: %d", err);
260 if (!this->
parent_->is_active()) {
261 ESP_LOGW(TAG,
"Cannot start scan while ESP32BLE is disabled.");
266 ESP_LOGE(TAG,
"start_scan called without holding scan_end_lock_");
270 ESP_LOGD(TAG,
"Starting scan...");
273 listener->on_scan_end();
277 this->
scan_params_.own_addr_type = BLE_ADDR_TYPE_PUBLIC;
278 this->
scan_params_.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL;
282 esp_err_t err = esp_ble_gap_set_scan_params(&this->
scan_params_);
284 ESP_LOGE(TAG,
"esp_ble_gap_set_scan_params failed: %d", err);
289 ESP_LOGE(TAG,
"esp_ble_gap_start_scanning failed: %d", err);
295 ESP_LOGE(TAG,
"ESP-IDF BLE scan never terminated, rebooting to restore BLE stack...");
303 ESP_LOGE(TAG,
"end_of_scan_ called without holding the scan_end_lock_");
307 ESP_LOGD(TAG,
"End of scan.");
314 listener->on_scan_end();
339 for (
auto *client : this->
clients_) {
350 case ESP_GAP_BLE_SCAN_RESULT_EVT:
353 case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
356 case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
359 case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
365 for (
auto *client : this->
clients_) {
366 client->gap_event_handler(event, param);
371 if (param.status == ESP_BT_STATUS_DONE) {
380 if (param.status == ESP_BT_STATUS_SUCCESS) {
393 if (param.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
400 }
else if (param.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
406 esp_ble_gattc_cb_param_t *param) {
407 for (
auto *client : this->
clients_) {
408 client->gattc_event_handler(event, gattc_if, param);
417 if (data.
data.size() != 23)
423 this->scan_result_ = param;
424 for (uint8_t i = 0; i < ESP_BD_ADDR_LEN; i++)
425 this->address_[i] = param.bda[i];
426 this->address_type_ = param.ble_addr_type;
427 this->rssi_ = param.rssi;
428 this->parse_adv_(param);
430 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE 431 ESP_LOGVV(TAG,
"Parse Result:");
432 const char *address_type =
"";
433 switch (this->address_type_) {
434 case BLE_ADDR_TYPE_PUBLIC:
435 address_type =
"PUBLIC";
437 case BLE_ADDR_TYPE_RANDOM:
438 address_type =
"RANDOM";
440 case BLE_ADDR_TYPE_RPA_PUBLIC:
441 address_type =
"RPA_PUBLIC";
443 case BLE_ADDR_TYPE_RPA_RANDOM:
444 address_type =
"RPA_RANDOM";
447 ESP_LOGVV(TAG,
" Address: %02X:%02X:%02X:%02X:%02X:%02X (%s)", this->address_[0], this->address_[1],
448 this->address_[2], this->address_[3], this->address_[4], this->address_[5], address_type);
450 ESP_LOGVV(TAG,
" RSSI: %d", this->rssi_);
451 ESP_LOGVV(TAG,
" Name: '%s'", this->name_.c_str());
452 for (
auto &it : this->tx_powers_) {
453 ESP_LOGVV(TAG,
" TX Power: %d", it);
455 if (this->appearance_.has_value()) {
456 ESP_LOGVV(TAG,
" Appearance: %u", *this->appearance_);
458 if (this->ad_flag_.has_value()) {
459 ESP_LOGVV(TAG,
" Ad Flag: %u", *this->ad_flag_);
461 for (
auto &uuid : this->service_uuids_) {
462 ESP_LOGVV(TAG,
" Service UUID: %s", uuid.to_string().c_str());
464 for (
auto &data : this->manufacturer_datas_) {
466 if (ibeacon.has_value()) {
467 ESP_LOGVV(TAG,
" Manufacturer iBeacon:");
468 ESP_LOGVV(TAG,
" UUID: %s", ibeacon.value().get_uuid().to_string().c_str());
469 ESP_LOGVV(TAG,
" Major: %u", ibeacon.value().get_major());
470 ESP_LOGVV(TAG,
" Minor: %u", ibeacon.value().get_minor());
471 ESP_LOGVV(TAG,
" TXPower: %d", ibeacon.value().get_signal_power());
473 ESP_LOGVV(TAG,
" Manufacturer ID: %s, data: %s", data.uuid.to_string().c_str(),
477 for (
auto &data : this->service_datas_) {
478 ESP_LOGVV(TAG,
" Service data:");
479 ESP_LOGVV(TAG,
" UUID: %s", data.uuid.to_string().c_str());
483 ESP_LOGVV(TAG,
" Adv data: %s",
format_hex_pretty(param.ble_adv, param.adv_data_len + param.scan_rsp_len).c_str());
488 const uint8_t *payload = param.ble_adv;
489 uint8_t
len = param.adv_data_len + param.scan_rsp_len;
491 while (offset + 2 < len) {
492 const uint8_t field_length = payload[offset++];
493 if (field_length == 0) {
498 const uint8_t record_type = payload[offset++];
499 const uint8_t *record = &payload[offset];
500 const uint8_t record_length = field_length - 1;
501 offset += record_length;
509 switch (record_type) {
510 case ESP_BLE_AD_TYPE_NAME_SHORT:
511 case ESP_BLE_AD_TYPE_NAME_CMPL: {
518 if (record_length > this->name_.length()) {
519 this->name_ = std::string(reinterpret_cast<const char *>(record), record_length);
523 case ESP_BLE_AD_TYPE_TX_PWR: {
527 this->tx_powers_.push_back(*payload);
530 case ESP_BLE_AD_TYPE_APPEARANCE: {
536 this->appearance_ = *
reinterpret_cast<const uint16_t *
>(record);
539 case ESP_BLE_AD_TYPE_FLAG: {
545 this->ad_flag_ = *record;
552 case ESP_BLE_AD_TYPE_16SRV_CMPL:
553 case ESP_BLE_AD_TYPE_16SRV_PART: {
555 for (uint8_t i = 0; i < record_length / 2; i++) {
556 this->service_uuids_.push_back(
ESPBTUUID::from_uint16(*reinterpret_cast<const uint16_t *>(record + 2 * i)));
560 case ESP_BLE_AD_TYPE_32SRV_CMPL:
561 case ESP_BLE_AD_TYPE_32SRV_PART: {
563 for (uint8_t i = 0; i < record_length / 4; i++) {
564 this->service_uuids_.push_back(
ESPBTUUID::from_uint32(*reinterpret_cast<const uint32_t *>(record + 4 * i)));
568 case ESP_BLE_AD_TYPE_128SRV_CMPL:
569 case ESP_BLE_AD_TYPE_128SRV_PART: {
574 case ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE: {
580 if (record_length < 2) {
581 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE");
586 data.data.assign(record + 2UL, record + record_length);
587 this->manufacturer_datas_.push_back(data);
594 case ESP_BLE_AD_TYPE_SERVICE_DATA: {
598 if (record_length < 2) {
599 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_SERVICE_DATA");
604 data.data.assign(record + 2UL, record + record_length);
605 this->service_datas_.push_back(data);
608 case ESP_BLE_AD_TYPE_32SERVICE_DATA: {
612 if (record_length < 4) {
613 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_32SERVICE_DATA");
618 data.data.assign(record + 4UL, record + record_length);
619 this->service_datas_.push_back(data);
622 case ESP_BLE_AD_TYPE_128SERVICE_DATA: {
626 if (record_length < 16) {
627 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_128SERVICE_DATA");
632 data.data.assign(record + 16UL, record + record_length);
633 this->service_datas_.push_back(data);
636 case ESP_BLE_AD_TYPE_INT_RANGE:
640 ESP_LOGV(TAG,
"Unhandled type: advType: 0x%02x", record_type);
648 snprintf(mac,
sizeof(mac),
"%02X:%02X:%02X:%02X:%02X:%02X", this->address_[0], this->address_[1], this->address_[2],
649 this->address_[3], this->address_[4], this->address_[5]);
655 ESP_LOGCONFIG(TAG,
"BLE Tracker:");
656 ESP_LOGCONFIG(TAG,
" Scan Duration: %" PRIu32
" s", this->
scan_duration_);
657 ESP_LOGCONFIG(TAG,
" Scan Interval: %.1f ms", this->
scan_interval_ * 0.625f);
658 ESP_LOGCONFIG(TAG,
" Scan Window: %.1f ms", this->
scan_window_ * 0.625f);
659 ESP_LOGCONFIG(TAG,
" Scan Type: %s", this->
scan_active_ ?
"ACTIVE" :
"PASSIVE");
660 ESP_LOGCONFIG(TAG,
" Continuous Scanning: %s", this->
scan_continuous_ ?
"True" :
"False");
669 this->already_discovered_.push_back(address);
673 const char *address_type_s;
675 case BLE_ADDR_TYPE_PUBLIC:
676 address_type_s =
"PUBLIC";
678 case BLE_ADDR_TYPE_RANDOM:
679 address_type_s =
"RANDOM";
681 case BLE_ADDR_TYPE_RPA_PUBLIC:
682 address_type_s =
"RPA_PUBLIC";
684 case BLE_ADDR_TYPE_RPA_RANDOM:
685 address_type_s =
"RPA_RANDOM";
688 address_type_s =
"UNKNOWN";
692 ESP_LOGD(TAG,
" Address Type: %s", address_type_s);
694 ESP_LOGD(TAG,
" Name: '%s'", device.
get_name().c_str());
697 ESP_LOGD(TAG,
" TX Power: %d", tx_power);
703 uint8_t ecb_plaintext[16];
704 uint8_t ecb_ciphertext[16];
708 memcpy(&ecb_key, irk, 16);
709 memset(&ecb_plaintext, 0, 16);
711 ecb_plaintext[13] = (addr64 >> 40) & 0xff;
712 ecb_plaintext[14] = (addr64 >> 32) & 0xff;
713 ecb_plaintext[15] = (addr64 >> 24) & 0xff;
715 mbedtls_aes_context ctx = {0, 0, {0}};
716 mbedtls_aes_init(&ctx);
718 if (mbedtls_aes_setkey_enc(&ctx, ecb_key, 128) != 0) {
719 mbedtls_aes_free(&ctx);
723 if (mbedtls_aes_crypt_ecb(&ctx, ESP_AES_ENCRYPT, ecb_plaintext, ecb_ciphertext) != 0) {
724 mbedtls_aes_free(&ctx);
728 mbedtls_aes_free(&ctx);
730 return ecb_ciphertext[15] == (addr64 & 0xff) && ecb_ciphertext[14] == ((addr64 >> 8) & 0xff) &&
731 ecb_ciphertext[13] == ((addr64 >> 16) & 0xff);
static const u_int8_t SCAN_RESULT_BUFFER_SIZE
void end_of_scan_()
Called when a scan ends.
uint64_t ble_addr_to_uint64(const esp_bd_addr_t address)
esp_bt_status_t scan_start_failed_
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.
bool cancel_timeout(const std::string &name)
Cancel a timeout function.
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 ble_before_disabled_event_handler() override
void set_timeout(const std::string &name, uint32_t timeout, std::function< void()> &&f)
Set a timeout function with a unique name.
void parse_scan_rst(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param ¶m)
An STL allocator that uses SPI RAM.
void recalculate_advertisement_parser_types()
const std::vector< int8_t > & get_tx_powers() const
std::string address_str() const
esp_bt_status_t scan_set_param_failed_
const float AFTER_BLUETOOTH
esp_ble_scan_params_t scan_params_
A structure holding the ESP BLE scan parameters.
SemaphoreHandle_t scan_end_lock_
void register_client(ESPBTClient *client)
ESP32BLETracker * global_esp32_ble_tracker
static ESPBTUUID from_uint32(uint32_t uuid)
void set_parent(ESP32BLETracker *parent)
void dump_config() override
esp_ble_gap_cb_param_t::ble_scan_result_evt_param * scan_result_buffer_
static ESPBTUUID from_uint16(uint16_t uuid)
Application App
Global storage of Application pointer - only one Application can exist.
bool parse_advertisements_
void add_on_state_callback(std::function< void(OTAState, float, uint8_t, OTAComponent *)> &&callback)
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 ¶m)
Called when a ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT event is received.
uint64_t address_uint64() const
uint8_t scan_start_fail_count_
SemaphoreHandle_t scan_result_lock_
uint32_t scan_duration_
The interval in seconds to perform scans.
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.
bool contains(uint8_t data1, uint8_t data2) const
void gap_scan_result_(const esp_ble_gap_cb_param_t::ble_scan_result_evt_param ¶m)
Called when a ESP_GAP_BLE_SCAN_RESULT_EVT event is received.
Implementation of SPI Controller mode.
static ESPBTUUID from_raw(const uint8_t *data)
void print_bt_device_info(const ESPBTDevice &device)
const std::string & get_name() const
OTAGlobalCallback * get_global_ota_callback()
float get_setup_priority() const override
size_t scan_result_index_
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.
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 ¶m)
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.