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> 32 namespace esp32_ble_tracker {
34 static const char *
const TAG =
"esp32_ble_tracker";
41 if (this->
parent_->is_failed()) {
43 ESP_LOGE(TAG,
"BLE Tracker was marked failed by ESP32BLE");
51 ESP_LOGE(TAG,
"Could not allocate buffer for BLE Tracker!");
55 global_esp32_ble_tracker =
this;
70 if (!this->
parent_->is_active()) {
83 int disconnecting = 0;
84 for (
auto *client : this->
clients_) {
85 switch (client->state()) {
103 bool promote_to_connecting = discovered && !searching && !connecting;
110 ESP_LOGW(TAG,
"Too many BLE events to process. Some devices may not show up.");
117 for (
auto *client : this->clients_) {
123 for (
size_t i = 0; i < index; i++) {
129 if (listener->parse_device(device))
133 for (
auto *client : this->clients_) {
134 if (client->parse_device(device)) {
137 promote_to_connecting =
true;
164 if (!connecting && !disconnecting && xSemaphoreTake(this->
scan_end_lock_, 0L)) {
180 ESP_LOGE(TAG,
"ESP-IDF BLE scan could not restart after 255 attempts, rebooting to restore BLE stack...");
186 ESP_LOGD(TAG,
"Stopping scan after failure...");
204 if (promote_to_connecting) {
205 for (
auto *client : this->clients_) {
215 ESP_LOGD(TAG,
"Pausing scan to make connection...");
228 ESP_LOGW(TAG,
"Scan requested when a scan is already in progress. Ignoring.");
233 ESP_LOGD(TAG,
"Stopping scan.");
248 esp_err_t err = esp_ble_gap_stop_scanning();
250 ESP_LOGE(TAG,
"esp_ble_gap_stop_scanning failed: %d", err);
256 if (!this->
parent_->is_active()) {
257 ESP_LOGW(TAG,
"Cannot start scan while ESP32BLE is disabled.");
262 ESP_LOGE(TAG,
"start_scan called without holding scan_end_lock_");
266 ESP_LOGD(TAG,
"Starting scan...");
269 listener->on_scan_end();
273 this->
scan_params_.own_addr_type = BLE_ADDR_TYPE_PUBLIC;
274 this->
scan_params_.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL;
278 esp_err_t err = esp_ble_gap_set_scan_params(&this->
scan_params_);
280 ESP_LOGE(TAG,
"esp_ble_gap_set_scan_params failed: %d", err);
285 ESP_LOGE(TAG,
"esp_ble_gap_start_scanning failed: %d", err);
291 ESP_LOGE(TAG,
"ESP-IDF BLE scan never terminated, rebooting to restore BLE stack...");
299 ESP_LOGE(TAG,
"end_of_scan_ called without holding the scan_end_lock_");
303 ESP_LOGD(TAG,
"End of scan.");
310 listener->on_scan_end();
335 for (
auto *client : this->
clients_) {
346 case ESP_GAP_BLE_SCAN_RESULT_EVT:
349 case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
352 case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
355 case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
361 for (
auto *client : this->
clients_) {
362 client->gap_event_handler(event, param);
367 if (param.status == ESP_BT_STATUS_DONE) {
376 if (param.status == ESP_BT_STATUS_SUCCESS) {
389 if (param.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
396 }
else if (param.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
402 esp_ble_gattc_cb_param_t *param) {
403 for (
auto *client : this->
clients_) {
404 client->gattc_event_handler(event, gattc_if, param);
413 if (data.
data.size() != 23)
419 this->scan_result_ = param;
420 for (uint8_t i = 0; i < ESP_BD_ADDR_LEN; i++)
421 this->address_[i] = param.bda[i];
422 this->address_type_ = param.ble_addr_type;
423 this->rssi_ = param.rssi;
424 this->parse_adv_(param);
426 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE 427 ESP_LOGVV(TAG,
"Parse Result:");
428 const char *address_type =
"";
429 switch (this->address_type_) {
430 case BLE_ADDR_TYPE_PUBLIC:
431 address_type =
"PUBLIC";
433 case BLE_ADDR_TYPE_RANDOM:
434 address_type =
"RANDOM";
436 case BLE_ADDR_TYPE_RPA_PUBLIC:
437 address_type =
"RPA_PUBLIC";
439 case BLE_ADDR_TYPE_RPA_RANDOM:
440 address_type =
"RPA_RANDOM";
443 ESP_LOGVV(TAG,
" Address: %02X:%02X:%02X:%02X:%02X:%02X (%s)", this->address_[0], this->address_[1],
444 this->address_[2], this->address_[3], this->address_[4], this->address_[5], address_type);
446 ESP_LOGVV(TAG,
" RSSI: %d", this->rssi_);
447 ESP_LOGVV(TAG,
" Name: '%s'", this->name_.c_str());
448 for (
auto &it : this->tx_powers_) {
449 ESP_LOGVV(TAG,
" TX Power: %d", it);
451 if (this->appearance_.has_value()) {
452 ESP_LOGVV(TAG,
" Appearance: %u", *this->appearance_);
454 if (this->ad_flag_.has_value()) {
455 ESP_LOGVV(TAG,
" Ad Flag: %u", *this->ad_flag_);
457 for (
auto &uuid : this->service_uuids_) {
458 ESP_LOGVV(TAG,
" Service UUID: %s", uuid.to_string().c_str());
460 for (
auto &data : this->manufacturer_datas_) {
462 if (this->get_ibeacon().has_value()) {
463 auto ibeacon = this->get_ibeacon().value();
464 ESP_LOGVV(TAG,
" iBeacon data:");
465 ESP_LOGVV(TAG,
" UUID: %s", ibeacon.get_uuid().to_string().c_str());
466 ESP_LOGVV(TAG,
" Major: %u", ibeacon.get_major());
467 ESP_LOGVV(TAG,
" Minor: %u", ibeacon.get_minor());
468 ESP_LOGVV(TAG,
" TXPower: %d", ibeacon.get_signal_power());
471 for (
auto &data : this->service_datas_) {
472 ESP_LOGVV(TAG,
" Service data:");
473 ESP_LOGVV(TAG,
" UUID: %s", data.uuid.to_string().c_str());
477 ESP_LOGVV(TAG,
"Adv data: %s",
format_hex_pretty(param.ble_adv, param.adv_data_len + param.scan_rsp_len).c_str());
482 const uint8_t *payload = param.ble_adv;
483 uint8_t
len = param.adv_data_len + param.scan_rsp_len;
485 while (offset + 2 < len) {
486 const uint8_t field_length = payload[offset++];
487 if (field_length == 0) {
492 const uint8_t record_type = payload[offset++];
493 const uint8_t *record = &payload[offset];
494 const uint8_t record_length = field_length - 1;
495 offset += record_length;
503 switch (record_type) {
504 case ESP_BLE_AD_TYPE_NAME_SHORT:
505 case ESP_BLE_AD_TYPE_NAME_CMPL: {
512 if (record_length > this->name_.length()) {
513 this->name_ = std::string(reinterpret_cast<const char *>(record), record_length);
517 case ESP_BLE_AD_TYPE_TX_PWR: {
521 this->tx_powers_.push_back(*payload);
524 case ESP_BLE_AD_TYPE_APPEARANCE: {
530 this->appearance_ = *
reinterpret_cast<const uint16_t *
>(record);
533 case ESP_BLE_AD_TYPE_FLAG: {
539 this->ad_flag_ = *record;
546 case ESP_BLE_AD_TYPE_16SRV_CMPL:
547 case ESP_BLE_AD_TYPE_16SRV_PART: {
549 for (uint8_t i = 0; i < record_length / 2; i++) {
550 this->service_uuids_.push_back(
ESPBTUUID::from_uint16(*reinterpret_cast<const uint16_t *>(record + 2 * i)));
554 case ESP_BLE_AD_TYPE_32SRV_CMPL:
555 case ESP_BLE_AD_TYPE_32SRV_PART: {
557 for (uint8_t i = 0; i < record_length / 4; i++) {
558 this->service_uuids_.push_back(
ESPBTUUID::from_uint32(*reinterpret_cast<const uint32_t *>(record + 4 * i)));
562 case ESP_BLE_AD_TYPE_128SRV_CMPL:
563 case ESP_BLE_AD_TYPE_128SRV_PART: {
568 case ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE: {
574 if (record_length < 2) {
575 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE");
580 data.data.assign(record + 2UL, record + record_length);
581 this->manufacturer_datas_.push_back(data);
588 case ESP_BLE_AD_TYPE_SERVICE_DATA: {
592 if (record_length < 2) {
593 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_SERVICE_DATA");
598 data.data.assign(record + 2UL, record + record_length);
599 this->service_datas_.push_back(data);
602 case ESP_BLE_AD_TYPE_32SERVICE_DATA: {
606 if (record_length < 4) {
607 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_32SERVICE_DATA");
612 data.data.assign(record + 4UL, record + record_length);
613 this->service_datas_.push_back(data);
616 case ESP_BLE_AD_TYPE_128SERVICE_DATA: {
620 if (record_length < 16) {
621 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_128SERVICE_DATA");
626 data.data.assign(record + 16UL, record + record_length);
627 this->service_datas_.push_back(data);
630 case ESP_BLE_AD_TYPE_INT_RANGE:
634 ESP_LOGV(TAG,
"Unhandled type: advType: 0x%02x", record_type);
642 snprintf(mac,
sizeof(mac),
"%02X:%02X:%02X:%02X:%02X:%02X", this->address_[0], this->address_[1], this->address_[2],
643 this->address_[3], this->address_[4], this->address_[5]);
649 ESP_LOGCONFIG(TAG,
"BLE Tracker:");
650 ESP_LOGCONFIG(TAG,
" Scan Duration: %" PRIu32
" s", this->
scan_duration_);
651 ESP_LOGCONFIG(TAG,
" Scan Interval: %.1f ms", this->
scan_interval_ * 0.625f);
652 ESP_LOGCONFIG(TAG,
" Scan Window: %.1f ms", this->
scan_window_ * 0.625f);
653 ESP_LOGCONFIG(TAG,
" Scan Type: %s", this->
scan_active_ ?
"ACTIVE" :
"PASSIVE");
654 ESP_LOGCONFIG(TAG,
" Continuous Scanning: %s", this->
scan_continuous_ ?
"True" :
"False");
663 this->already_discovered_.push_back(address);
667 const char *address_type_s;
669 case BLE_ADDR_TYPE_PUBLIC:
670 address_type_s =
"PUBLIC";
672 case BLE_ADDR_TYPE_RANDOM:
673 address_type_s =
"RANDOM";
675 case BLE_ADDR_TYPE_RPA_PUBLIC:
676 address_type_s =
"RPA_PUBLIC";
678 case BLE_ADDR_TYPE_RPA_RANDOM:
679 address_type_s =
"RPA_RANDOM";
682 address_type_s =
"UNKNOWN";
686 ESP_LOGD(TAG,
" Address Type: %s", address_type_s);
688 ESP_LOGD(TAG,
" Name: '%s'", device.
get_name().c_str());
691 ESP_LOGD(TAG,
" TX Power: %d", tx_power);
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 add_on_state_callback(std::function< void(OTAState, float, uint8_t)> &&callback)
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_
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
OTAComponent * global_ota_component
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.
This is a workaround until we can figure out a way to get the tflite-micro idf component code availab...
static ESPBTUUID from_raw(const uint8_t *data)
void print_bt_device_info(const ESPBTDevice &device)
const std::string & get_name() const
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.