Upstream
/
esphome
mirror of https://github.com/esphome/esphome.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

[esp32_ble] Attempt to manage memory better with shared_ptr

This commit is contained in:
Jesse Hills 2024-05-24 16:48:23 +12:00
parent 9d03f47233
commit 01899d70bc
No known key found for this signature in database
GPG Key ID: BEAAE804EFD8E83A
14 changed files with 260 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
esphome/components/esp32_ble/ble_uuid.cpp
View File

@ -2,9 +2,9 @@
#ifdef USE_ESP32
#include <cstring>
#include <cstdio>
#include <cinttypes>
#include <cstdio>
#include <cstring>
#include "esphome/core/log.h"
namespace esphome {
@ -31,14 +31,15 @@ ESPBTUUID ESPBTUUID::from_raw(const uint8_t *data) {
memcpy(ret.uuid_.uuid.uuid128, data, ESP_UUID_LEN_128);
return ret;
}
ESPBTUUID ESPBTUUID::from_raw(const std::string &data) {
ESPBTUUID ESPBTUUID::from_raw(const std::string &data) { return ESPBTUUID::from_raw(data.data(), data.length()); }
ESPBTUUID ESPBTUUID::from_raw(const char *data, size_t len) {
ESPBTUUID ret;
if (data.length() == 4) {
if (len == 4) {
ret.uuid_.len = ESP_UUID_LEN_16;
ret.uuid_.uuid.uuid16 = 0;
for (int i = 0; i < data.length();) {
uint8_t msb = data.c_str()[i];
uint8_t lsb = data.c_str()[i + 1];
for (int i = 0; i < len;) {
uint8_t msb = data[i];
uint8_t lsb = data[i + 1];
if (msb > '9')
msb -= 7;
@ -47,12 +48,12 @@ ESPBTUUID ESPBTUUID::from_raw(const std::string &data) {
ret.uuid_.uuid.uuid16 += (((msb & 0x0F) << 4) | (lsb & 0x0F)) << (2 - i) * 4;
i += 2;
}
} else if (data.length() == 8) {
} else if (len == 8) {
ret.uuid_.len = ESP_UUID_LEN_32;
ret.uuid_.uuid.uuid32 = 0;
for (int i = 0; i < data.length();) {
uint8_t msb = data.c_str()[i];
uint8_t lsb = data.c_str()[i + 1];
for (int i = 0; i < len;) {
uint8_t msb = data[i];
uint8_t lsb = data[i + 1];
if (msb > '9')
msb -= 7;
@ -61,20 +62,20 @@ ESPBTUUID ESPBTUUID::from_raw(const std::string &data) {
ret.uuid_.uuid.uuid32 += (((msb & 0x0F) << 4) | (lsb & 0x0F)) << (6 - i) * 4;
i += 2;
}
} else if (data.length() == 16) { // how we can have 16 byte length string reprezenting 128 bit uuid??? needs to be
// investigated (lack of time)
} else if (len == 16) { // how we can have 16 byte length string reprezenting 128 bit uuid??? needs to be
// investigated (lack of time)
ret.uuid_.len = ESP_UUID_LEN_128;
memcpy(ret.uuid_.uuid.uuid128, (uint8_t *) data.data(), 16);
} else if (data.length() == 36) {
memcpy(ret.uuid_.uuid.uuid128, (uint8_t *) data, 16);
} else if (len == 36) {
// If the length of the string is 36 bytes then we will assume it is a long hex string in
// UUID format.
ret.uuid_.len = ESP_UUID_LEN_128;
int n = 0;
for (int i = 0; i < data.length();) {
if (data.c_str()[i] == '-')
for (int i = 0; i < len;) {
if (data[i] == '-')
i++;
uint8_t msb = data.c_str()[i];
uint8_t lsb = data.c_str()[i + 1];
uint8_t msb = data[i];
uint8_t lsb = data[i + 1];
if (msb > '9')
msb -= 7;
@ -84,7 +85,7 @@ ESPBTUUID ESPBTUUID::from_raw(const std::string &data) {
i += 2;
}
} else {
ESP_LOGE(TAG, "ERROR: UUID value not 2, 4, 16 or 36 bytes - %s", data.c_str());
ESP_LOGE(TAG, "ERROR: UUID value not 2, 4, 16 or 36 bytes - %s", data);
}
return ret;
}
@ -162,14 +163,19 @@ bool ESPBTUUID::operator==(const ESPBTUUID &uuid) const {
return false;
}
esp_bt_uuid_t ESPBTUUID::get_uuid() const { return this->uuid_; }
std::string ESPBTUUID::to_string() const {
std::string ESPBTUUID::to_string() {
if (!this->string_.empty())
return this->string_;
switch (this->uuid_.len) {
case ESP_UUID_LEN_16:
return str_snprintf("0x%02X%02X", 6, this->uuid_.uuid.uuid16 >> 8, this->uuid_.uuid.uuid16 & 0xff);
this->string_ = str_snprintf("0x%02X%02X", 6, this->uuid_.uuid.uuid16 >> 8, this->uuid_.uuid.uuid16 & 0xff);
return this->string_;
case ESP_UUID_LEN_32:
return str_snprintf("0x%02" PRIX32 "%02" PRIX32 "%02" PRIX32 "%02" PRIX32, 10, (this->uuid_.uuid.uuid32 >> 24),
(this->uuid_.uuid.uuid32 >> 16 & 0xff), (this->uuid_.uuid.uuid32 >> 8 & 0xff),
this->uuid_.uuid.uuid32 & 0xff);
this->string_ = str_snprintf("0x%02" PRIX32 "%02" PRIX32 "%02" PRIX32 "%02" PRIX32, 10,
(this->uuid_.uuid.uuid32 >> 24), (this->uuid_.uuid.uuid32 >> 16 & 0xff),
(this->uuid_.uuid.uuid32 >> 8 & 0xff), this->uuid_.uuid.uuid32 & 0xff);
return this->string_;
default:
case ESP_UUID_LEN_128:
std::string buf;
@ -178,6 +184,7 @@ std::string ESPBTUUID::to_string() const {
if (i == 6 || i == 8 || i == 10 || i == 12)
buf += "-";
}
this->string_ = buf;
return buf;
}
return "";

9
esphome/components/esp32_ble/ble_uuid.h
View File

@ -1,12 +1,12 @@
#pragma once
#include "esphome/core/helpers.h"
#include "esphome/core/hal.h"
#include "esphome/core/helpers.h"
#ifdef USE_ESP32
#include <string>
#include <esp_bt_defs.h>
#include <string>
namespace esphome {
namespace esp32_ble {
@ -23,6 +23,8 @@ class ESPBTUUID {
static ESPBTUUID from_raw(const std::string &data);
static ESPBTUUID from_raw(const char *uuid, size_t len);
static ESPBTUUID from_uuid(esp_bt_uuid_t uuid);
ESPBTUUID as_128bit() const;
@ -34,10 +36,11 @@ class ESPBTUUID {
esp_bt_uuid_t get_uuid() const;
std::string to_string() const;
std::string to_string();
protected:
esp_bt_uuid_t uuid_;
std::string string_;
};
} // namespace esp32_ble

3
esphome/components/esp32_ble_server/ble_2901.cpp
View File

@ -8,6 +8,9 @@ namespace esp32_ble_server {
BLE2901::BLE2901(const std::string &value) : BLE2901((uint8_t *) value.data(), value.length()) {}
BLE2901::BLE2901(const uint8_t *data, size_t length) : BLEDescriptor(esp32_ble::ESPBTUUID::from_uint16(0x2901)) {
if (this->state_ == FAILED) {
return;
}
this->set_value(data, length);
this->permissions_ = ESP_GATT_PERM_READ;
}

5
esphome/components/esp32_ble_server/ble_2902.cpp
View File

@ -1,6 +1,8 @@
#include "ble_2902.h"
#include "esphome/components/esp32_ble/ble_uuid.h"
#include "esphome/core/log.h"
#ifdef USE_ESP32
#include <cstring>
@ -9,6 +11,9 @@ namespace esphome {
namespace esp32_ble_server {
BLE2902::BLE2902() : BLEDescriptor(esp32_ble::ESPBTUUID::from_uint16(0x2902)) {
if (this->state_ == FAILED) {
return;
}
this->value_.attr_len = 2;
uint8_t data[2] = {0, 0};
memcpy(this->value_.attr_value, data, 2);

49
esphome/components/esp32_ble_server/ble_characteristic.cpp
View File

@ -1,4 +1,6 @@
#include "ble_characteristic.h"
#include "ble_2901.h"
#include "ble_2902.h"
#include "ble_server.h"
#include "ble_service.h"
@ -12,14 +14,17 @@ namespace esp32_ble_server {
static const char *const TAG = "esp32_ble_server.characteristic";
BLECharacteristic::~BLECharacteristic() {
for (auto *descriptor : this->descriptors_) {
delete descriptor; // NOLINT(cppcoreguidelines-owning-memory)
}
this->descriptors_.clear();
vSemaphoreDelete(this->set_value_lock_);
}
BLECharacteristic::BLECharacteristic(const ESPBTUUID uuid, uint32_t properties) : uuid_(uuid) {
this->set_value_lock_ = xSemaphoreCreateBinary();
if (this->set_value_lock_ == nullptr) {
ESP_LOGE(TAG, "Failed to create set_value_lock_ semaphore");
this->state_ = FAILED;
return;
}
xSemaphoreGive(this->set_value_lock_);
this->properties_ = (esp_gatt_char_prop_t) 0;
@ -103,14 +108,36 @@ void BLECharacteristic::notify(bool notification) {
}
}
void BLECharacteristic::add_descriptor(BLEDescriptor *descriptor) { this->descriptors_.push_back(descriptor); }
void BLECharacteristic::add_descriptor(std::shared_ptr<BLEDescriptor> descriptor) {
this->descriptors_.push_back(descriptor);
}
void BLECharacteristic::remove_descriptor(BLEDescriptor *descriptor) {
void BLECharacteristic::remove_descriptor(std::shared_ptr<BLEDescriptor> descriptor) {
this->descriptors_.erase(std::remove(this->descriptors_.begin(), this->descriptors_.end(), descriptor),
this->descriptors_.end());
}
void BLECharacteristic::do_create(BLEService *service) {
std::shared_ptr<BLE2901> BLECharacteristic::make_2901_descriptor(const std::string &value) {
auto descriptor = std::make_shared<BLE2901>(value);
if (descriptor == nullptr) {
ESP_LOGE(TAG, "Failed to allocate BLE2901 descriptor");
return nullptr;
}
this->add_descriptor(descriptor);
return descriptor;
}
std::shared_ptr<BLE2902> BLECharacteristic::make_2902_descriptor() {
auto descriptor = std::make_shared<BLE2902>();
if (descriptor == nullptr) {
ESP_LOGE(TAG, "Failed to allocate BLE2902 descriptor");
return nullptr;
}
this->add_descriptor(descriptor);
return descriptor;
}
void BLECharacteristic::do_create(std::shared_ptr<BLEService> service) {
this->service_ = service;
esp_attr_control_t control;
control.auto_rsp = ESP_GATT_RSP_BY_APP;
@ -137,7 +164,7 @@ bool BLECharacteristic::is_created() {
return false;
bool created = true;
for (auto *descriptor : this->descriptors_) {
for (auto descriptor : this->descriptors_) {
created &= descriptor->is_created();
}
if (created)
@ -150,7 +177,7 @@ bool BLECharacteristic::is_failed() {
return true;
bool failed = false;
for (auto *descriptor : this->descriptors_) {
for (auto descriptor : this->descriptors_) {
failed |= descriptor->is_failed();
}
if (failed)
@ -208,8 +235,8 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
if (this->uuid_ == ESPBTUUID::from_uuid(param->add_char.char_uuid)) {
this->handle_ = param->add_char.attr_handle;
for (auto *descriptor : this->descriptors_) {
descriptor->do_create(this);
for (auto descriptor : this->descriptors_) {
descriptor->do_create(shared_from_this());
}
this->state_ = CREATING_DEPENDENTS;
@ -313,7 +340,7 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
break;
}
for (auto *descriptor : this->descriptors_) {
for (auto descriptor : this->descriptors_) {
descriptor->gatts_event_handler(event, gatts_if, param);
}
}

23
esphome/components/esp32_ble_server/ble_characteristic.h
View File

@ -1,17 +1,21 @@
#pragma once
#include "ble_2901.h"
#include "ble_2902.h"
#include "ble_descriptor.h"
#include "esphome/components/esp32_ble/ble_uuid.h"
#include <memory>
#include <vector>
#ifdef USE_ESP32
#include <esp_bt_defs.h>
#include <esp_gap_ble_api.h>
#include <esp_gatt_defs.h>
#include <esp_gattc_api.h>
#include <esp_gatts_api.h>
#include <esp_bt_defs.h>
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>
@ -22,7 +26,7 @@ using namespace esp32_ble;
class BLEService;
class BLECharacteristic {
class BLECharacteristic : public std::enable_shared_from_this<BLECharacteristic> {
public:
BLECharacteristic(ESPBTUUID uuid, uint32_t properties);
~BLECharacteristic();
@ -47,15 +51,18 @@ class BLECharacteristic {
void notify(bool notification = true);
void do_create(BLEService *service);
void do_create(std::shared_ptr<BLEService> service);
void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param);
void on_write(const std::function<void(const std::vector<uint8_t> &)> &&func) { this->on_write_ = func; }
void add_descriptor(BLEDescriptor *descriptor);
void remove_descriptor(BLEDescriptor *descriptor);
void add_descriptor(std::shared_ptr<BLEDescriptor> descriptor);
void remove_descriptor(std::shared_ptr<BLEDescriptor> descriptor);
BLEService *get_service() { return this->service_; }
std::shared_ptr<BLE2901> make_2901_descriptor(const std::string &value);
std::shared_ptr<BLE2902> make_2902_descriptor();
std::shared_ptr<BLEService> get_service() { return this->service_; }
ESPBTUUID get_uuid() { return this->uuid_; }
std::vector<uint8_t> &get_value() { return this->value_; }
@ -71,7 +78,7 @@ class BLECharacteristic {
protected:
bool write_event_{false};
BLEService *service_;
std::shared_ptr<BLEService> service_;
ESPBTUUID uuid_;
esp_gatt_char_prop_t properties_;
uint16_t handle_{0xFFFF};
@ -80,7 +87,7 @@ class BLECharacteristic {
std::vector<uint8_t> value_;
SemaphoreHandle_t set_value_lock_;
std::vector<BLEDescriptor *> descriptors_;
std::vector<std::shared_ptr<BLEDescriptor>> descriptors_;
std::function<void(const std::vector<uint8_t> &)> on_write_;

21
esphome/components/esp32_ble_server/ble_descriptor.cpp
View File

@ -1,8 +1,12 @@
#include "ble_descriptor.h"
#include "ble_characteristic.h"
#include "ble_service.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
#include "esphome/core/application.h"
#include <cstring>
#ifdef USE_ESP32
@ -16,12 +20,23 @@ BLEDescriptor::BLEDescriptor(ESPBTUUID uuid, uint16_t max_len) {
this->uuid_ = uuid;
this->value_.attr_len = 0;
this->value_.attr_max_len = max_len;
this->value_.attr_value = (uint8_t *) malloc(max_len); // NOLINT
ExternalRAMAllocator<uint8_t> allocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
this->value_.attr_value = allocator.allocate(max_len);
if (this->value_.attr_value == nullptr) {
ESP_LOGE(TAG, "Failed to allocate %d bytes for value", max_len);
this->state_ = FAILED;
return;
}
}
BLEDescriptor::~BLEDescriptor() { free(this->value_.attr_value); } // NOLINT
BLEDescriptor::~BLEDescriptor() {
ExternalRAMAllocator<uint8_t> deallocator(ExternalRAMAllocator<uint8_t>::ALLOW_FAILURE);
deallocator.deallocate(this->value_.attr_value, this->value_.attr_max_len);
this->value_.attr_value = nullptr;
}
void BLEDescriptor::do_create(BLECharacteristic *characteristic) {
void BLEDescriptor::do_create(std::shared_ptr<BLECharacteristic> characteristic) {
this->characteristic_ = characteristic;
esp_attr_control_t control;
control.auto_rsp = ESP_GATT_AUTO_RSP;

4
esphome/components/esp32_ble_server/ble_descriptor.h
View File

@ -18,7 +18,7 @@ class BLEDescriptor {
public:
BLEDescriptor(ESPBTUUID uuid, uint16_t max_len = 100);
virtual ~BLEDescriptor();
void do_create(BLECharacteristic *characteristic);
void do_create(std::shared_ptr<BLECharacteristic> characteristic);
void set_value(const std::string &value);
void set_value(const uint8_t *data, size_t length);
@ -29,7 +29,7 @@ class BLEDescriptor {
bool is_failed() { return this->state_ == FAILED; }
protected:
BLECharacteristic *characteristic_{nullptr};
std::shared_ptr<BLECharacteristic> characteristic_{nullptr};
ESPBTUUID uuid_;
uint16_t handle_{0xFFFF};

59
esphome/components/esp32_ble_server/ble_server.cpp
View File

@ -1,18 +1,18 @@
#include "ble_server.h"
#include "esphome/components/esp32_ble/ble.h"
#include "esphome/core/log.h"
#include "esphome/core/application.h"
#include "esphome/core/log.h"
#include "esphome/core/version.h"
#ifdef USE_ESP32
#include <nvs_flash.h>
#include <freertos/FreeRTOSConfig.h>
#include <esp_bt_main.h>
#include <esp_bt.h>
#include <freertos/task.h>
#include <esp_bt_main.h>
#include <esp_gap_ble_api.h>
#include <freertos/FreeRTOSConfig.h>
#include <freertos/task.h>
#include <nvs_flash.h>
namespace esphome {
namespace esp32_ble_server {
@ -58,9 +58,8 @@ void BLEServer::loop() {
pair.second->do_create(this);
}
if (this->device_information_service_ == nullptr) {
this->create_service(ESPBTUUID::from_uint16(DEVICE_INFORMATION_SERVICE_UUID));
this->device_information_service_ =
this->get_service(ESPBTUUID::from_uint16(DEVICE_INFORMATION_SERVICE_UUID));
this->create_service(ESPBTUUID::from_uint16(DEVICE_INFORMATION_SERVICE_UUID));
this->create_device_characteristics_();
}
this->state_ = STARTING_SERVICE;
@ -94,56 +93,58 @@ void BLEServer::restart_advertising_() {
}
bool BLEServer::create_device_characteristics_() {
std::shared_ptr<BLECharacteristic> model =
this->device_information_service_->create_characteristic(MODEL_UUID, BLECharacteristic::PROPERTY_READ);
if (this->model_.has_value()) {
BLECharacteristic *model =
this->device_information_service_->create_characteristic(MODEL_UUID, BLECharacteristic::PROPERTY_READ);
model->set_value(this->model_.value());
} else {
BLECharacteristic *model =
this->device_information_service_->create_characteristic(MODEL_UUID, BLECharacteristic::PROPERTY_READ);
model->set_value(ESPHOME_BOARD);
}
BLECharacteristic *version =
std::shared_ptr<BLECharacteristic> version =
this->device_information_service_->create_characteristic(VERSION_UUID, BLECharacteristic::PROPERTY_READ);
version->set_value("ESPHome " ESPHOME_VERSION);
BLECharacteristic *manufacturer =
std::shared_ptr<BLECharacteristic> manufacturer =
this->device_information_service_->create_characteristic(MANUFACTURER_UUID, BLECharacteristic::PROPERTY_READ);
manufacturer->set_value(this->manufacturer_);
return true;
}
void BLEServer::create_service(ESPBTUUID uuid, bool advertise, uint16_t num_handles, uint8_t inst_id) {
ESP_LOGV(TAG, "Creating BLE service - %s", uuid.to_string().c_str());
std::shared_ptr<BLEService> BLEServer::create_service(ESPBTUUID uuid, bool advertise, uint16_t num_handles,
uint8_t inst_id) {
std::string uuid_str = uuid.to_string();
// If the service already exists, do nothing
BLEService *service = this->get_service(uuid);
std::shared_ptr<BLEService> service = this->get_service(uuid);
if (service != nullptr) {
ESP_LOGW(TAG, "BLE service %s already exists", uuid.to_string().c_str());
return;
ESP_LOGW(TAG, "BLE service %s already exists", uuid_str.c_str());
return service;
}
service = new BLEService(uuid, num_handles, inst_id, advertise); // NOLINT(cppcoreguidelines-owning-memory)
this->services_.emplace(uuid.to_string(), service);
ESP_LOGV(TAG, "Creating BLE service - %s", uuid_str.c_str());
service = std::make_shared<BLEService>(uuid, num_handles, inst_id, advertise);
this->services_.emplace(uuid_str, service);
service->do_create(this);
return service;
}
void BLEServer::remove_service(ESPBTUUID uuid) {
ESP_LOGV(TAG, "Removing BLE service - %s", uuid.to_string().c_str());
BLEService *service = this->get_service(uuid);
std::string uuid_str = uuid.to_string();
std::shared_ptr<BLEService> service = this->get_service(uuid);
if (service == nullptr) {
ESP_LOGW(TAG, "BLE service %s not found", uuid.to_string().c_str());
ESP_LOGW(TAG, "BLE service %s not found", uuid_str.c_str());
return;
}
ESP_LOGV(TAG, "Removing BLE service - %s", uuid_str.c_str());
service->do_delete();
delete service; // NOLINT(cppcoreguidelines-owning-memory)
this->services_.erase(uuid.to_string());
this->services_.erase(uuid_str);
}
BLEService *BLEServer::get_service(ESPBTUUID uuid) {
BLEService *service = nullptr;
if (this->services_.count(uuid.to_string()) > 0) {
service = this->services_.at(uuid.to_string());
std::shared_ptr<BLEService> BLEServer::get_service(ESPBTUUID uuid) {
std::string uuid_str = uuid.to_string();
std::shared_ptr<BLEService> service = nullptr;
if (this->services_.count(uuid_str) > 0) {
service = this->services_.at(uuid_str);
}
return service;
}

13
esphome/components/esp32_ble_server/ble_server.h
View File

@ -1,7 +1,7 @@
#pragma once
#include "ble_service.h"
#include "ble_characteristic.h"
#include "ble_service.h"
#include "esphome/components/esp32_ble/ble.h"
#include "esphome/components/esp32_ble/ble_advertising.h"
@ -12,8 +12,8 @@
#include "esphome/core/preferences.h"
#include <memory>
#include <vector>
#include <unordered_map>
#include <vector>
#ifdef USE_ESP32
@ -51,9 +51,10 @@ class BLEServer : public Component, public GATTsEventHandler, public BLEStatusEv
this->restart_advertising_();
}
void create_service(ESPBTUUID uuid, bool advertise = false, uint16_t num_handles = 15, uint8_t inst_id = 0);
std::shared_ptr<BLEService> create_service(ESPBTUUID uuid, bool advertise = false, uint16_t num_handles = 15,
uint8_t inst_id = 0);
void remove_service(ESPBTUUID uuid);
BLEService *get_service(ESPBTUUID uuid);
std::shared_ptr<BLEService> get_service(ESPBTUUID uuid);
esp_gatt_if_t get_gatts_if() { return this->gatts_if_; }
uint32_t get_connected_client_count() { return this->connected_clients_; }
@ -81,8 +82,8 @@ class BLEServer : public Component, public GATTsEventHandler, public BLEStatusEv
uint32_t connected_clients_{0};
std::unordered_map<uint16_t, void *> clients_;
std::unordered_map<std::string, BLEService *> services_;
BLEService *device_information_service_;
std::unordered_map<std::string, std::shared_ptr<BLEService>> services_;
std::shared_ptr<BLEService> device_information_service_;
std::vector<BLEServiceComponent *> service_components_;

36
esphome/components/esp32_ble_server/ble_service.cpp
View File

@ -12,31 +12,33 @@ static const char *const TAG = "esp32_ble_server.service";
BLEService::BLEService(ESPBTUUID uuid, uint16_t num_handles, uint8_t inst_id, bool advertise)
: uuid_(uuid), num_handles_(num_handles), inst_id_(inst_id), advertise_(advertise) {}
BLEService::~BLEService() {
for (auto &chr : this->characteristics_)
delete chr; // NOLINT(cppcoreguidelines-owning-memory)
}
BLECharacteristic *BLEService::get_characteristic(ESPBTUUID uuid) {
for (auto *chr : this->characteristics_) {
std::shared_ptr<BLECharacteristic> BLEService::get_characteristic(ESPBTUUID uuid) {
for (auto chr : this->characteristics_) {
if (chr->get_uuid() == uuid)
return chr;
}
return nullptr;
}
BLECharacteristic *BLEService::get_characteristic(uint16_t uuid) {
std::shared_ptr<BLECharacteristic> BLEService::get_characteristic(uint16_t uuid) {
return this->get_characteristic(ESPBTUUID::from_uint16(uuid));
}
BLECharacteristic *BLEService::create_characteristic(uint16_t uuid, esp_gatt_char_prop_t properties) {
std::shared_ptr<BLECharacteristic> BLEService::create_characteristic(uint16_t uuid, esp_gatt_char_prop_t properties) {
return create_characteristic(ESPBTUUID::from_uint16(uuid), properties);
}
BLECharacteristic *BLEService::create_characteristic(const std::string &uuid, esp_gatt_char_prop_t properties) {
std::shared_ptr<BLECharacteristic> BLEService::create_characteristic(const std::string &uuid,
esp_gatt_char_prop_t properties) {
return create_characteristic(ESPBTUUID::from_raw(uuid), properties);
}
BLECharacteristic *BLEService::create_characteristic(ESPBTUUID uuid, esp_gatt_char_prop_t properties) {
// NOLINTNEXTLINE(cppcoreguidelines-owning-memory)
BLECharacteristic *characteristic = new BLECharacteristic(uuid, properties);
std::shared_ptr<BLECharacteristic> BLEService::create_characteristic(const char *uuid, size_t len,
esp_gatt_char_prop_t properties) {
return create_characteristic(ESPBTUUID::from_raw(uuid, len), properties);
}
std::shared_ptr<BLECharacteristic> BLEService::create_characteristic(ESPBTUUID uuid, esp_gatt_char_prop_t properties) {
auto characteristic = std::make_shared<BLECharacteristic>(uuid, properties);
if (characteristic == nullptr) {
return nullptr;
}
this->characteristics_.push_back(characteristic);
return characteristic;
}
@ -80,9 +82,9 @@ bool BLEService::do_create_characteristics_() {
if (this->last_created_characteristic_ != nullptr && !this->last_created_characteristic_->is_created())
return true; // Signifies that the previous characteristic is still being created.
auto *characteristic = this->characteristics_[this->created_characteristic_count_++];
auto characteristic = this->characteristics_[this->created_characteristic_count_++];
this->last_created_characteristic_ = characteristic;
characteristic->do_create(this);
characteristic->do_create(shared_from_this());
return true;
}
@ -124,7 +126,7 @@ bool BLEService::is_failed() {
if (this->init_state_ == FAILED)
return true;
bool failed = false;
for (auto *characteristic : this->characteristics_)
for (auto characteristic : this->characteristics_)
failed |= characteristic->is_failed();
if (failed)
@ -166,7 +168,7 @@ void BLEService::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t g
break;
}
for (auto *characteristic : this->characteristics_) {
for (auto characteristic : this->characteristics_) {
characteristic->gatts_event_handler(event, gatts_if, param);
}
}

23
esphome/components/esp32_ble_server/ble_service.h
View File

@ -3,6 +3,7 @@
#include "ble_characteristic.h"
#include "esphome/components/esp32_ble/ble_uuid.h"
#include <memory>
#include <vector>
#ifdef USE_ESP32
@ -20,19 +21,21 @@ class BLEServer;
using namespace esp32_ble;
class BLEService {
class BLEService : public std::enable_shared_from_this<BLEService> {
public:
BLEService(ESPBTUUID uuid, uint16_t num_handles, uint8_t inst_id, bool advertise);
~BLEService();
BLECharacteristic *get_characteristic(ESPBTUUID uuid);
BLECharacteristic *get_characteristic(uint16_t uuid);
BLECharacteristic *create_characteristic(const std::string &uuid, esp_gatt_char_prop_t properties);
BLECharacteristic *create_characteristic(uint16_t uuid, esp_gatt_char_prop_t properties);
BLECharacteristic *create_characteristic(ESPBTUUID uuid, esp_gatt_char_prop_t properties);
std::shared_ptr<BLECharacteristic> get_characteristic(ESPBTUUID uuid);
std::shared_ptr<BLECharacteristic> get_characteristic(uint16_t uuid);
std::shared_ptr<BLECharacteristic> create_characteristic(const char *uuid, size_t len,
esp_gatt_char_prop_t properties);
std::shared_ptr<BLECharacteristic> create_characteristic(const std::string &uuid, esp_gatt_char_prop_t properties);
std::shared_ptr<BLECharacteristic> create_characteristic(uint16_t uuid, esp_gatt_char_prop_t properties);
std::shared_ptr<BLECharacteristic> create_characteristic(ESPBTUUID uuid, esp_gatt_char_prop_t properties);
ESPBTUUID get_uuid() { return this->uuid_; }
BLECharacteristic *get_last_created_characteristic() { return this->last_created_characteristic_; }
std::shared_ptr<BLECharacteristic> get_last_created_characteristic() { return this->last_created_characteristic_; }
uint16_t get_handle() { return this->handle_; }
BLEServer *get_server() { return this->server_; }
@ -52,8 +55,8 @@ class BLEService {
bool is_deleted() { return this->init_state_ == DELETED; }
protected:
std::vector<BLECharacteristic *> characteristics_;
BLECharacteristic *last_created_characteristic_{nullptr};
std::vector<std::shared_ptr<BLECharacteristic>> characteristics_;
std::shared_ptr<BLECharacteristic> last_created_characteristic_{nullptr};
uint32_t created_characteristic_count_{0};
BLEServer *server_;
ESPBTUUID uuid_;

89
esphome/components/esp32_improv/esp32_improv_component.cpp
View File

@ -1,12 +1,13 @@
#include "esp32_improv_component.h"
#include "esphome/components/esp32_ble/ble.h"
#include "esphome/components/esp32_ble_server/ble_2902.h"
#include "esphome/core/application.h"
#include "esphome/core/log.h"
#ifdef USE_ESP32
static constexpr size_t MAX_UUID_LENGTH = 37;
namespace esphome {
namespace esp32_improv {
@ -28,35 +29,72 @@ void ESP32ImprovComponent::setup() {
#endif
}
void ESP32ImprovComponent::setup_characteristics() {
this->status_ = this->service_->create_characteristic(
improv::STATUS_UUID, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
BLEDescriptor *status_descriptor = new BLE2902();
this->status_->add_descriptor(status_descriptor);
bool ESP32ImprovComponent::setup_characteristics() {
this->status_ =
this->service_->create_characteristic(improv::STATUS_UUID, strnlen(improv::STATUS_UUID, MAX_UUID_LENGTH),
BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
if (this->status_ == nullptr) {
ESP_LOGE(TAG, "Failed to create status characteristic");
return false;
}
this->error_ = this->service_->create_characteristic(
improv::ERROR_UUID, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
BLEDescriptor *error_descriptor = new BLE2902();
this->error_->add_descriptor(error_descriptor);
if (!this->status_->make_2902_descriptor()) {
ESP_LOGE(TAG, "Failed to create status descriptor");
return false;
}
this->rpc_ = this->service_->create_characteristic(improv::RPC_COMMAND_UUID, BLECharacteristic::PROPERTY_WRITE);
this->error_ =
this->service_->create_characteristic(improv::ERROR_UUID, strnlen(improv::ERROR_UUID, MAX_UUID_LENGTH),
BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
if (this->error_ == nullptr) {
ESP_LOGE(TAG, "Failed to create error characteristic");
return false;
}
if (!this->error_->make_2902_descriptor()) {
ESP_LOGE(TAG, "Failed to create error descriptor");
return false;
}
this->rpc_ = this->service_->create_characteristic(
improv::RPC_COMMAND_UUID, strnlen(improv::RPC_COMMAND_UUID, MAX_UUID_LENGTH), BLECharacteristic::PROPERTY_WRITE);
if (this->rpc_ == nullptr) {
ESP_LOGE(TAG, "Failed to create rpc characteristic");
return false;
}
this->rpc_->on_write([this](const std::vector<uint8_t> &data) {
if (!data.empty()) {
this->incoming_data_.insert(this->incoming_data_.end(), data.begin(), data.end());
}
});
BLEDescriptor *rpc_descriptor = new BLE2902();
this->rpc_->add_descriptor(rpc_descriptor);
if (this->rpc_->make_2902_descriptor() == nullptr) {
ESP_LOGE(TAG, "Failed to create rpc descriptor");
return false;
}
this->rpc_response_ = this->service_->create_characteristic(
improv::RPC_RESULT_UUID, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
BLEDescriptor *rpc_response_descriptor = new BLE2902();
this->rpc_response_->add_descriptor(rpc_response_descriptor);
this->rpc_response_ =
this->service_->create_characteristic(improv::RPC_RESULT_UUID, strnlen(improv::RPC_RESULT_UUID, MAX_UUID_LENGTH),
BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
if (this->rpc_response_ == nullptr) {
ESP_LOGE(TAG, "Failed to create rpc response characteristic");
return false;
}
if (!this->rpc_response_->make_2902_descriptor()) {
ESP_LOGE(TAG, "Failed to create rpc response descriptor");
return false;
}
this->capabilities_ = this->service_->create_characteristic(
improv::CAPABILITIES_UUID, strnlen(improv::CAPABILITIES_UUID, MAX_UUID_LENGTH), BLECharacteristic::PROPERTY_READ);
if (this->capabilities_ == nullptr) {
ESP_LOGE(TAG, "Failed to create capabilities characteristic");
return false;
}
if (!this->capabilities_->make_2902_descriptor()) {
ESP_LOGE(TAG, "Failed to create capabilities descriptor");
return false;
}
this->capabilities_ =
this->service_->create_characteristic(improv::CAPABILITIES_UUID, BLECharacteristic::PROPERTY_READ);
BLEDescriptor *capabilities_descriptor = new BLE2902();
this->capabilities_->add_descriptor(capabilities_descriptor);
uint8_t capabilities = 0x00;
#ifdef USE_OUTPUT
if (this->status_indicator_ != nullptr)
@ -64,6 +102,7 @@ void ESP32ImprovComponent::setup_characteristics() {
#endif
this->capabilities_->set_value(capabilities);
this->setup_complete_ = true;
return true;
}
void ESP32ImprovComponent::loop() {
@ -75,9 +114,11 @@ void ESP32ImprovComponent::loop() {
if (this->service_ == nullptr) {
// Setup the service
ESP_LOGD(TAG, "Creating Improv service");
global_ble_server->create_service(ESPBTUUID::from_raw(improv::SERVICE_UUID), true);
this->service_ = global_ble_server->get_service(ESPBTUUID::from_raw(improv::SERVICE_UUID));
this->setup_characteristics();
this->service_ = global_ble_server->create_service(ESPBTUUID::from_raw(improv::SERVICE_UUID), true);
if (!this->setup_characteristics()) {
this->mark_failed();
return;
}
}
if (!this->incoming_data_.empty())

14
esphome/components/esp32_improv/esp32_improv_component.h
View File

@ -34,7 +34,7 @@ class ESP32ImprovComponent : public Component, public BLEServiceComponent {
void dump_config() override;
void loop() override;
void setup() override;
void setup_characteristics();
bool setup_characteristics();
void on_client_disconnect() override;
float get_setup_priority() const override;
@ -68,12 +68,12 @@ class ESP32ImprovComponent : public Component, public BLEServiceComponent {
std::vector<uint8_t> incoming_data_;
wifi::WiFiAP connecting_sta_;
BLEService *service_ = nullptr;
BLECharacteristic *status_;
BLECharacteristic *error_;
BLECharacteristic *rpc_;
BLECharacteristic *rpc_response_;
BLECharacteristic *capabilities_;
std::shared_ptr<BLEService> service_{nullptr};
std::shared_ptr<BLECharacteristic> status_;
std::shared_ptr<BLECharacteristic> error_;
std::shared_ptr<BLECharacteristic> rpc_;
std::shared_ptr<BLECharacteristic> rpc_response_;
std::shared_ptr<BLECharacteristic> capabilities_;
#ifdef USE_BINARY_SENSOR
binary_sensor::BinarySensor *authorizer_{nullptr};