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> 24 #include <esp32-hal-bt.h> 31 namespace esp32_ble_tracker {
33 static const char *
const TAG =
"esp32_ble_tracker";
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;
51 if (this->
parent_->is_failed()) {
53 ESP_LOGE(TAG,
"BLE Tracker was marked failed by ESP32BLE");
61 ESP_LOGE(TAG,
"Could not allocate buffer for BLE Tracker!");
65 global_esp32_ble_tracker =
this;
82 ESP_LOGW(TAG,
"Cannot start scan!");
91 int disconnecting = 0;
92 for (
auto *client : this->
clients_) {
93 switch (client->state()) {
111 bool promote_to_connecting = discovered && !searching && !connecting;
119 ESP_LOGW(TAG,
"Too many BLE events to process. Some devices may not show up.");
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();
292 case ESP_GAP_BLE_SCAN_RESULT_EVT:
295 case ESP_GAP_BLE_SCAN_PARAM_SET_COMPLETE_EVT:
298 case ESP_GAP_BLE_SCAN_START_COMPLETE_EVT:
301 case ESP_GAP_BLE_SCAN_STOP_COMPLETE_EVT:
307 for (
auto *client : this->
clients_) {
308 client->gap_event_handler(event, param);
318 if (param.status == ESP_BT_STATUS_SUCCESS) {
331 if (param.search_evt == ESP_GAP_SEARCH_INQ_RES_EVT) {
338 }
else if (param.search_evt == ESP_GAP_SEARCH_INQ_CMPL_EVT) {
344 esp_ble_gattc_cb_param_t *param) {
345 for (
auto *client : this->
clients_) {
346 client->gattc_event_handler(event, gattc_if, param);
355 if (data.
data.size() != 23)
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);
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";
375 case BLE_ADDR_TYPE_RANDOM:
376 address_type =
"RANDOM";
378 case BLE_ADDR_TYPE_RPA_PUBLIC:
379 address_type =
"RPA_PUBLIC";
381 case BLE_ADDR_TYPE_RPA_RANDOM:
382 address_type =
"RPA_RANDOM";
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);
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);
393 if (this->appearance_.has_value()) {
394 ESP_LOGVV(TAG,
" Appearance: %u", *this->appearance_);
396 if (this->ad_flag_.has_value()) {
397 ESP_LOGVV(TAG,
" Ad Flag: %u", *this->ad_flag_);
399 for (
auto &uuid : this->service_uuids_) {
400 ESP_LOGVV(TAG,
" Service UUID: %s", uuid.to_string().c_str());
402 for (
auto &data : this->manufacturer_datas_) {
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());
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());
419 ESP_LOGVV(TAG,
"Adv data: %s",
format_hex_pretty(param.ble_adv, param.adv_data_len + param.scan_rsp_len).c_str());
424 const uint8_t *payload = param.ble_adv;
425 uint8_t
len = param.adv_data_len + param.scan_rsp_len;
427 while (offset + 2 < len) {
428 const uint8_t field_length = payload[offset++];
429 if (field_length == 0) {
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;
445 switch (record_type) {
446 case ESP_BLE_AD_TYPE_NAME_SHORT:
447 case ESP_BLE_AD_TYPE_NAME_CMPL: {
454 if (record_length > this->name_.length()) {
455 this->name_ = std::string(reinterpret_cast<const char *>(record), record_length);
459 case ESP_BLE_AD_TYPE_TX_PWR: {
463 this->tx_powers_.push_back(*payload);
466 case ESP_BLE_AD_TYPE_APPEARANCE: {
472 this->appearance_ = *
reinterpret_cast<const uint16_t *
>(record);
475 case ESP_BLE_AD_TYPE_FLAG: {
481 this->ad_flag_ = *record;
488 case ESP_BLE_AD_TYPE_16SRV_CMPL:
489 case ESP_BLE_AD_TYPE_16SRV_PART: {
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)));
496 case ESP_BLE_AD_TYPE_32SRV_CMPL:
497 case ESP_BLE_AD_TYPE_32SRV_PART: {
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)));
504 case ESP_BLE_AD_TYPE_128SRV_CMPL:
505 case ESP_BLE_AD_TYPE_128SRV_PART: {
510 case ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE: {
516 if (record_length < 2) {
517 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE");
522 data.data.assign(record + 2UL, record + record_length);
523 this->manufacturer_datas_.push_back(data);
530 case ESP_BLE_AD_TYPE_SERVICE_DATA: {
534 if (record_length < 2) {
535 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_SERVICE_DATA");
540 data.data.assign(record + 2UL, record + record_length);
541 this->service_datas_.push_back(data);
544 case ESP_BLE_AD_TYPE_32SERVICE_DATA: {
548 if (record_length < 4) {
549 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_32SERVICE_DATA");
554 data.data.assign(record + 4UL, record + record_length);
555 this->service_datas_.push_back(data);
558 case ESP_BLE_AD_TYPE_128SERVICE_DATA: {
562 if (record_length < 16) {
563 ESP_LOGV(TAG,
"Record length too small for ESP_BLE_AD_TYPE_128SERVICE_DATA");
568 data.data.assign(record + 16UL, record + record_length);
569 this->service_datas_.push_back(data);
572 case ESP_BLE_AD_TYPE_INT_RANGE:
576 ESP_LOGV(TAG,
"Unhandled type: advType: 0x%02x", record_type);
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]);
591 ESP_LOGCONFIG(TAG,
"BLE Tracker:");
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");
605 this->already_discovered_.push_back(address);
609 const char *address_type_s;
611 case BLE_ADDR_TYPE_PUBLIC:
612 address_type_s =
"PUBLIC";
614 case BLE_ADDR_TYPE_RANDOM:
615 address_type_s =
"RANDOM";
617 case BLE_ADDR_TYPE_RPA_PUBLIC:
618 address_type_s =
"RPA_PUBLIC";
620 case BLE_ADDR_TYPE_RPA_RANDOM:
621 address_type_s =
"RPA_RANDOM";
624 address_type_s =
"UNKNOWN";
628 ESP_LOGD(TAG,
" Address Type: %s", address_type_s);
630 ESP_LOGD(TAG,
" Name: '%s'", device.
get_name().c_str());
633 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.
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 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)
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 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.
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.
uint64_t ble_addr_to_uint64(const esp_bd_addr_t address)
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.