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;
72 ESP_LOGW(TAG,
"Cannot start scan!");
81 int disconnecting = 0;
82 for (
auto *client : this->
clients_) {
83 switch (client->state()) {
101 bool promote_to_connecting = discovered && !searching && !connecting;
108 ESP_LOGW(TAG,
"Too many BLE events to process. Some devices may not show up.");
115 for (
auto *client : this->clients_) {
121 for (
size_t i = 0; i < index; i++) {
127 if (listener->parse_device(device))
131 for (
auto *client : this->clients_) {
132 if (client->parse_device(device)) {
135 promote_to_connecting =
true;
162 if (!connecting && !disconnecting && xSemaphoreTake(this->
scan_end_lock_, 0L)) {
178 ESP_LOGE(TAG,
"ESP-IDF BLE scan could not restart after 255 attempts, rebooting to restore BLE stack...");
184 ESP_LOGD(TAG,
"Stopping scan after failure...");
185 esp_ble_gap_stop_scanning();
203 if (promote_to_connecting) {
204 for (
auto *client : this->clients_) {
214 ESP_LOGD(TAG,
"Pausing scan to make connection...");
215 esp_ble_gap_stop_scanning();
228 ESP_LOGW(TAG,
"Scan requested when a scan is already in progress. Ignoring.");
233 ESP_LOGD(TAG,
"Stopping scan.");
235 esp_ble_gap_stop_scanning();
242 ESP_LOGE(TAG,
"start_scan called without holding scan_end_lock_");
246 ESP_LOGD(TAG,
"Starting scan...");
249 listener->on_scan_end();
254 this->
scan_params_.own_addr_type = BLE_ADDR_TYPE_PUBLIC;
255 this->
scan_params_.scan_filter_policy = BLE_SCAN_FILTER_ALLOW_ALL;
263 ESP_LOGE(TAG,
"ESP-IDF BLE scan never terminated, rebooting to restore BLE stack...");
271 ESP_LOGE(TAG,
"end_of_scan_ called without holding the scan_end_lock_");
275 ESP_LOGD(TAG,
"End of scan.");
282 listener->on_scan_end();
307 for (
auto *client : this->
clients_) {
318 case ESP_GAP_BLE_SCAN_RESULT_EVT:
321 case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
324 case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
327 case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
333 for (
auto *client : this->
clients_) {
334 client->gap_event_handler(event, param);
344 if (param.status == ESP_BT_STATUS_SUCCESS) {
357 if (param.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
364 }
else if (param.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
370 esp_ble_gattc_cb_param_t *param) {
371 for (
auto *client : this->
clients_) {
372 client->gattc_event_handler(event, gattc_if, param);
381 if (data.
data.size() != 23)
387 this->scan_result_ = param;
388 for (uint8_t i = 0; i < ESP_BD_ADDR_LEN; i++)
389 this->address_[i] = param.bda[i];
390 this->address_type_ = param.ble_addr_type;
391 this->rssi_ = param.rssi;
392 this->parse_adv_(param);
394 #ifdef ESPHOME_LOG_HAS_VERY_VERBOSE 395 ESP_LOGVV(TAG,
"Parse Result:");
396 const char *address_type =
"";
397 switch (this->address_type_) {
398 case BLE_ADDR_TYPE_PUBLIC:
399 address_type =
"PUBLIC";
401 case BLE_ADDR_TYPE_RANDOM:
402 address_type =
"RANDOM";
404 case BLE_ADDR_TYPE_RPA_PUBLIC:
405 address_type =
"RPA_PUBLIC";
407 case BLE_ADDR_TYPE_RPA_RANDOM:
408 address_type =
"RPA_RANDOM";
411 ESP_LOGVV(TAG,
" Address: %02X:%02X:%02X:%02X:%02X:%02X (%s)", this->address_[0], this->address_[1],
412 this->address_[2], this->address_[3], this->address_[4], this->address_[5], address_type);
414 ESP_LOGVV(TAG,
" RSSI: %d", this->rssi_);
415 ESP_LOGVV(TAG,
" Name: '%s'", this->name_.c_str());
416 for (
auto &it : this->tx_powers_) {
417 ESP_LOGVV(TAG,
" TX Power: %d", it);
419 if (this->appearance_.has_value()) {
420 ESP_LOGVV(TAG,
" Appearance: %u", *this->appearance_);
422 if (this->ad_flag_.has_value()) {
423 ESP_LOGVV(TAG,
" Ad Flag: %u", *this->ad_flag_);
425 for (
auto &uuid : this->service_uuids_) {
426 ESP_LOGVV(TAG,
" Service UUID: %s", uuid.to_string().c_str());
428 for (
auto &data : this->manufacturer_datas_) {
430 if (this->get_ibeacon().has_value()) {
431 auto ibeacon = this->get_ibeacon().value();
432 ESP_LOGVV(TAG,
" iBeacon data:");
433 ESP_LOGVV(TAG,
" UUID: %s", ibeacon.get_uuid().to_string().c_str());
434 ESP_LOGVV(TAG,
" Major: %u", ibeacon.get_major());
435 ESP_LOGVV(TAG,
" Minor: %u", ibeacon.get_minor());
436 ESP_LOGVV(TAG,
" TXPower: %d", ibeacon.get_signal_power());
439 for (
auto &data : this->service_datas_) {
440 ESP_LOGVV(TAG,
" Service data:");
441 ESP_LOGVV(TAG,
" UUID: %s", data.uuid.to_string().c_str());
445 ESP_LOGVV(TAG,
"Adv data: %s",
format_hex_pretty(param.ble_adv, param.adv_data_len + param.scan_rsp_len).c_str());
450 const uint8_t *payload = param.ble_adv;
451 uint8_t
len = param.adv_data_len + param.scan_rsp_len;
453 while (offset + 2 < len) {
454 const uint8_t field_length = payload[offset++];
455 if (field_length == 0) {
460 const uint8_t record_type = payload[offset++];
461 const uint8_t *record = &payload[offset];
462 const uint8_t record_length = field_length - 1;
463 offset += record_length;
471 switch (record_type) {
472 case ESP_BLE_AD_TYPE_NAME_SHORT:
473 case ESP_BLE_AD_TYPE_NAME_CMPL: {
480 if (record_length > this->name_.length()) {
481 this->name_ = std::string(reinterpret_cast<const char *>(record), record_length);
485 case ESP_BLE_AD_TYPE_TX_PWR: {
489 this->tx_powers_.push_back(*payload);
492 case ESP_BLE_AD_TYPE_APPEARANCE: {
498 this->appearance_ = *
reinterpret_cast<const uint16_t *
>(record);
501 case ESP_BLE_AD_TYPE_FLAG: {
507 this->ad_flag_ = *record;
514 case ESP_BLE_AD_TYPE_16SRV_CMPL:
515 case ESP_BLE_AD_TYPE_16SRV_PART: {
517 for (uint8_t i = 0; i < record_length / 2; i++) {
518 this->service_uuids_.push_back(
ESPBTUUID::from_uint16(*reinterpret_cast<const uint16_t *>(record + 2 * i)));
522 case ESP_BLE_AD_TYPE_32SRV_CMPL:
523 case ESP_BLE_AD_TYPE_32SRV_PART: {
525 for (uint8_t i = 0; i < record_length / 4; i++) {
526 this->service_uuids_.push_back(
ESPBTUUID::from_uint32(*reinterpret_cast<const uint32_t *>(record + 4 * i)));
530 case ESP_BLE_AD_TYPE_128SRV_CMPL:
531 case ESP_BLE_AD_TYPE_128SRV_PART: {
536 case ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE: {
542 if (record_length < 2) {
543 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE");
548 data.data.assign(record + 2UL, record + record_length);
549 this->manufacturer_datas_.push_back(data);
556 case ESP_BLE_AD_TYPE_SERVICE_DATA: {
560 if (record_length < 2) {
561 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_SERVICE_DATA");
566 data.data.assign(record + 2UL, record + record_length);
567 this->service_datas_.push_back(data);
570 case ESP_BLE_AD_TYPE_32SERVICE_DATA: {
574 if (record_length < 4) {
575 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_32SERVICE_DATA");
580 data.data.assign(record + 4UL, record + record_length);
581 this->service_datas_.push_back(data);
584 case ESP_BLE_AD_TYPE_128SERVICE_DATA: {
588 if (record_length < 16) {
589 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_128SERVICE_DATA");
594 data.data.assign(record + 16UL, record + record_length);
595 this->service_datas_.push_back(data);
598 case ESP_BLE_AD_TYPE_INT_RANGE:
602 ESP_LOGV(TAG,
"Unhandled type: advType: 0x%02x", record_type);
610 snprintf(mac,
sizeof(mac),
"%02X:%02X:%02X:%02X:%02X:%02X", this->address_[0], this->address_[1], this->address_[2],
611 this->address_[3], this->address_[4], this->address_[5]);
617 ESP_LOGCONFIG(TAG,
"BLE Tracker:");
618 ESP_LOGCONFIG(TAG,
" Scan Duration: %" PRIu32
" s", this->
scan_duration_);
619 ESP_LOGCONFIG(TAG,
" Scan Interval: %.1f ms", this->
scan_interval_ * 0.625f);
620 ESP_LOGCONFIG(TAG,
" Scan Window: %.1f ms", this->
scan_window_ * 0.625f);
621 ESP_LOGCONFIG(TAG,
" Scan Type: %s", this->
scan_active_ ?
"ACTIVE" :
"PASSIVE");
622 ESP_LOGCONFIG(TAG,
" Continuous Scanning: %s", this->
scan_continuous_ ?
"True" :
"False");
631 this->already_discovered_.push_back(address);
635 const char *address_type_s;
637 case BLE_ADDR_TYPE_PUBLIC:
638 address_type_s =
"PUBLIC";
640 case BLE_ADDR_TYPE_RANDOM:
641 address_type_s =
"RANDOM";
643 case BLE_ADDR_TYPE_RPA_PUBLIC:
644 address_type_s =
"RPA_PUBLIC";
646 case BLE_ADDR_TYPE_RPA_RANDOM:
647 address_type_s =
"RPA_RANDOM";
650 address_type_s =
"UNKNOWN";
654 ESP_LOGD(TAG,
" Address Type: %s", address_type_s);
656 ESP_LOGD(TAG,
" Name: '%s'", device.
get_name().c_str());
659 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 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.
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.