Home-IoT/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2024-11-23 23:48:11 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Add BLE characteristic events

Browse source
This commit is contained in:
Rapsssito 2024-10-19 17:38:09 +02:00
parent 0e05f95b17
commit 36b3a8bac3
6 changed files with 208 additions and 135 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

294
esphome/components/esp32_ble_server/__init__.py
View file

@ -30,7 +30,9 @@ CONF_BROADCAST = "broadcast"
CONF_INDICATE = "indicate"
CONF_WRITE_NO_RESPONSE = "write_no_response"
CONF_DESCRIPTORS = "descriptors"
CONF_VALUE_ACTION_ID_ = "value_action_id_"
CONF_STRING_ENCODING = "string_encoding"
CONF_CHAR_VALUE_ACTION_ID_ = "characteristic_value_action_id_"
CONF_VALUE_BUFFER_ = "value_buffer_"
# Core key to store the global configuration
@ -72,7 +74,7 @@ PROPERTY_MAP = {
}
def validate_on_write(char_config):
def validate_char_on_write(char_config):
if CONF_ON_WRITE in char_config:
if not char_config[CONF_WRITE] and not char_config[CONF_WRITE_NO_RESPONSE]:
raise cv.Invalid(
@ -81,6 +83,15 @@ def validate_on_write(char_config):
return char_config
def validate_desc_on_write(desc_config):
if CONF_ON_WRITE in desc_config:
if not desc_config[CONF_WRITE]:
raise cv.Invalid(
f"{CONF_ON_WRITE} requires the {CONF_WRITE} property to be set"
)
return desc_config
def validate_notify_action(action_char_id):
# Store the characteristic ID in the global data for the final validation
if _KEY_NOTIFY_REQUIRED not in CORE.data:
@ -89,6 +100,18 @@ def validate_notify_action(action_char_id):
return action_char_id
def validate_descritor_value_length(descriptor_conf):
# Check if the value length is specified for the descriptor if the value is a templatable
if (
cg.is_template(descriptor_conf[CONF_VALUE])
and CONF_BYTE_LENGTH not in descriptor_conf
):
raise cv.Invalid(
f"Descriptor {descriptor_conf[CONF_UUID]} is a templatable value and the {CONF_BYTE_LENGTH} property is not set"
)
return descriptor_conf
def final_validate_config(config):
# Check if all characteristics that require notifications have the notify property set
if _KEY_NOTIFY_REQUIRED in CORE.data:
@ -102,61 +125,65 @@ def final_validate_config(config):
][0]
if not char_config[CONF_NOTIFY]:
raise cv.Invalid(
f"Characteristic {char_id} has notify actions and the {CONF_NOTIFY} property is not set"
f"Characteristic {char_config[CONF_UUID]} has notify actions and the {CONF_NOTIFY} property is not set"
)
return config
DESCRIPTOR_VALUE_SCHEMA = cv.Any(
VALUE_SCHEMA = cv.Any(
cv.boolean,
cv.float_,
cv.uint8_t,
cv.uint16_t,
cv.uint32_t,
cv.int_,
cv.All(cv.ensure_list(cv.uint8_t), cv.Length(min=1)),
cv.float_,
cv.templatable(cv.All(cv.ensure_list(cv.uint8_t), cv.Length(min=1))),
cv.string,
)
CHARACTERISTIC_VALUE_SCHEMA = cv.Any(
cv.boolean,
cv.float_,
cv.uint8_t,
cv.uint16_t,
cv.uint32_t,
cv.int_,
cv.templatable(cv.All(cv.ensure_list(cv.uint8_t), cv.Length(min=1))),
cv.string,
VALUE_EXTRAS_SCHEMA = cv.Schema(
{
cv.Optional(CONF_STRING_ENCODING, default="utf-8"): cv.string,
cv.Optional(CONF_BYTE_LENGTH): cv.uint16_t,
cv.GenerateID(CONF_VALUE_BUFFER_): cv.declare_id(ByteBuffer),
}
)
DESCRIPTOR_SCHEMA = cv.Schema(
{
cv.GenerateID(): cv.declare_id(BLEDescriptor),
cv.Required(CONF_UUID): bt_uuid,
cv.Required(CONF_VALUE): DESCRIPTOR_VALUE_SCHEMA,
cv.Optional(CONF_BYTE_LENGTH): cv.uint16_t,
cv.GenerateID(CONF_VALUE_BUFFER_): cv.declare_id(ByteBuffer),
}
)
SERVICE_CHARACTERISTIC_SCHEMA = cv.Schema(
{
cv.GenerateID(): cv.declare_id(BLECharacteristic),
cv.Required(CONF_UUID): bt_uuid,
cv.Optional(CONF_WRITE_NO_RESPONSE, default=False): cv.boolean,
cv.Optional(CONF_VALUE): CHARACTERISTIC_VALUE_SCHEMA,
cv.Optional(CONF_BYTE_LENGTH): cv.uint16_t,
cv.GenerateID(CONF_VALUE_BUFFER_): cv.declare_id(ByteBuffer),
cv.GenerateID(CONF_VALUE_ACTION_ID_): cv.declare_id(
BLECharacteristicSetValueAction
),
cv.Optional(CONF_DESCRIPTORS, default=[]): cv.ensure_list(DESCRIPTOR_SCHEMA),
cv.Optional(CONF_READ, default=True): cv.boolean,
cv.Optional(CONF_WRITE, default=True): cv.boolean,
cv.Optional(CONF_ON_WRITE): automation.validate_automation(
{cv.GenerateID(): cv.declare_id(BLECharacteristic)}, single=True
{cv.GenerateID(): cv.declare_id(BLEDescriptor)}, single=True
),
cv.Required(CONF_VALUE): VALUE_SCHEMA,
},
extra_schemas=[validate_on_write],
).extend({cv.Optional(k, default=False): cv.boolean for k in PROPERTY_MAP})
extra_schemas=[validate_descritor_value_length, validate_desc_on_write],
).extend(VALUE_EXTRAS_SCHEMA)
SERVICE_CHARACTERISTIC_SCHEMA = (
cv.Schema(
{
cv.GenerateID(): cv.declare_id(BLECharacteristic),
cv.Required(CONF_UUID): bt_uuid,
cv.Optional(CONF_VALUE): VALUE_SCHEMA,
cv.GenerateID(CONF_CHAR_VALUE_ACTION_ID_): cv.declare_id(
BLECharacteristicSetValueAction
),
cv.Optional(CONF_DESCRIPTORS, default=[]): cv.ensure_list(
DESCRIPTOR_SCHEMA
),
cv.Optional(CONF_ON_WRITE): automation.validate_automation(
{cv.GenerateID(): cv.declare_id(BLECharacteristic)}, single=True
),
},
extra_schemas=[validate_char_on_write],
)
.extend({cv.Optional(k, default=False): cv.boolean for k in PROPERTY_MAP})
.extend(VALUE_EXTRAS_SCHEMA)
)
SERVICE_SCHEMA = cv.Schema(
{
@ -190,65 +217,43 @@ def parse_properties(char_conf):
)
def _parse_value_(value, buffer_id, byte_length=None):
# Compute the maximum length of the value
# Also parse the value for byte arrays
for val_method, put_method in zip(
def bytebuffer_parser_(value, str_encoding):
for val_method, casting in zip(
(
cv.boolean,
cv.float_,
cv.uint8_t,
cv.uint16_t,
cv.uint32_t,
cv.int_,
cv.float_,
cv.string,
cv.All(cv.ensure_list(cv.uint8_t), cv.Length(min=1)),
),
(
"put_bool",
"put_float",
"put_uint8",
"put_uint16",
"put_uint32",
"put_int",
"put_vector",
cg.bool_,
cg.uint8,
cg.uint16,
cg.uint32,
cg.int_,
cg.float_,
None,
cg.std_vector.template(cg.uint8),
),
):
try:
val = val_method(value)
if byte_length is None:
# If no byte length is specified, use the default length
buffer_var = cg.variable(buffer_id, ByteBuffer_ns.wrap(val))
if val_method == cv.string:
# Convert to a list of bytes using encoding
val = cg.std_vector.template(cg.uint8)(list(val.encode(str_encoding)))
else:
# Create a buffer with the specified length and add the value
buffer_var = cg.variable(buffer_id, ByteBuffer(byte_length))
if isinstance(val, str):
# Split in characters
val = [ord(c) for c in val]
cg.add(getattr(buffer_var, put_method)(val))
return buffer_var, buffer_var.get_capacity()
val = casting(val)
return val, val_method
except cv.Invalid:
pass
# Assume it's a list of bytes
try:
val = cv.All(cv.ensure_list(cv.uint8_t), cv.Length(min=1))(value)
if byte_length is None:
buffer_var = cg.variable(
buffer_id, ByteBuffer_ns.wrap(cg.std_vector.template(cg.uint8)(val))
)
else:
buffer_var = cg.variable(buffer_id, ByteBuffer(byte_length))
cg.add(buffer_var.put_vector(val))
return buffer_var, buffer_var.get_capacity()
except cv.Invalid:
pass
raise cv.Invalid(f"Could not find type for value: {value}")
def parse_descriptor_value(value, buffer_id, byte_length=None):
return _parse_value_(value, buffer_id, byte_length)
async def parse_characteristic_value(value, buffer_id, args):
async def parse_value(value, str_encoding, buffer_id, args, byte_length=None):
if isinstance(value, cv.Lambda):
return await cg.templatable(
value,
@ -256,7 +261,25 @@ async def parse_characteristic_value(value, buffer_id, args):
ByteBuffer,
ByteBuffer_ns.wrap,
)
return _parse_value_(value, buffer_id)[0]
val, val_method = bytebuffer_parser_(value, str_encoding)
if byte_length is None:
# If no byte length is specified, use the default length
buffer_var = cg.variable(buffer_id, ByteBuffer_ns.wrap(val))
else:
put_method_dict = {
cv.boolean: "put_bool",
cv.uint8_t: "put_uint8",
cv.uint16_t: "put_uint16",
cv.uint32_t: "put_uint32",
cv.int_: "put_int",
cv.float_: "put_float",
}
# Create a buffer with the specified length and add the value
put_method = put_method_dict.get(val_method, "put_vector")
buffer_var = cg.variable(buffer_id, ByteBuffer(byte_length))
cg.add(getattr(buffer_var, put_method)(val))
return buffer_var
def calculate_num_handles(service_config):
@ -268,6 +291,66 @@ def calculate_num_handles(service_config):
return total
async def to_code_descriptor(descriptor_conf, char_var):
value = await parse_value(
descriptor_conf[CONF_VALUE],
descriptor_conf[CONF_STRING_ENCODING],
descriptor_conf[CONF_VALUE_BUFFER_],
{},
descriptor_conf.get(CONF_BYTE_LENGTH, None),
)
desc_var = cg.new_Pvariable(
descriptor_conf[CONF_ID],
ESPBTUUID_ns.from_raw(descriptor_conf[CONF_UUID]),
value.get_capacity(),
descriptor_conf[CONF_READ],
descriptor_conf[CONF_WRITE],
)
cg.add(char_var.add_descriptor(desc_var))
cg.add(desc_var.set_value(value))
if CONF_ON_WRITE in descriptor_conf:
on_write_conf = descriptor_conf[CONF_ON_WRITE]
await automation.build_automation(
BLETriggers_ns.create_descriptor_on_write_trigger(desc_var),
[(cg.std_vector.template(cg.uint8), "x")],
on_write_conf,
)
async def to_code_characteristic(service_var, char_conf):
char_var = cg.Pvariable(
char_conf[CONF_ID],
service_var.create_characteristic(
ESPBTUUID_ns.from_raw(char_conf[CONF_UUID]),
parse_properties(char_conf),
),
)
if CONF_ON_WRITE in char_conf:
on_write_conf = char_conf[CONF_ON_WRITE]
await automation.build_automation(
BLETriggers_ns.create_characteristic_on_write_trigger(char_var),
[(cg.std_vector.template(cg.uint8), "x")],
on_write_conf,
)
if CONF_VALUE in char_conf:
action_conf = {
CONF_ID: char_conf[CONF_ID],
CONF_VALUE: char_conf[CONF_VALUE],
CONF_BYTE_LENGTH: char_conf.get(CONF_BYTE_LENGTH, None),
CONF_STRING_ENCODING: char_conf[CONF_STRING_ENCODING],
CONF_VALUE_BUFFER_: char_conf[CONF_VALUE_BUFFER_],
}
value_action = await ble_server_characteristic_set_value(
action_conf,
char_conf[CONF_CHAR_VALUE_ACTION_ID_],
cg.TemplateArguments(None),
{},
)
cg.add(value_action.play())
for descriptor_conf in char_conf[CONF_DESCRIPTORS]:
await to_code_descriptor(descriptor_conf, char_var)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
@ -294,48 +377,7 @@ async def to_code(config):
),
)
for char_conf in service_config[CONF_CHARACTERISTICS]:
char_var = cg.Pvariable(
char_conf[CONF_ID],
service_var.create_characteristic(
ESPBTUUID_ns.from_raw(char_conf[CONF_UUID]),
parse_properties(char_conf),
),
)
if CONF_ON_WRITE in char_conf:
on_write_conf = char_conf[CONF_ON_WRITE]
await automation.build_automation(
BLETriggers_ns.create_on_write_trigger(char_var),
[(cg.std_vector.template(cg.uint8), "x")],
on_write_conf,
)
if CONF_VALUE in char_conf:
action_conf = {
CONF_ID: char_conf[CONF_ID],
CONF_VALUE: char_conf[CONF_VALUE],
CONF_BYTE_LENGTH: char_conf.get(CONF_BYTE_LENGTH, None),
CONF_VALUE_BUFFER_: char_conf[CONF_VALUE_BUFFER_],
}
value_action = await ble_server_characteristic_set_value(
action_conf,
char_conf[CONF_VALUE_ACTION_ID_],
cg.TemplateArguments(None),
{},
)
cg.add(value_action.play())
for descriptor_conf in char_conf[CONF_DESCRIPTORS]:
descriptor_value, max_length = parse_descriptor_value(
descriptor_conf[CONF_VALUE],
descriptor_conf[CONF_VALUE_BUFFER_],
descriptor_conf.get(CONF_BYTE_LENGTH, None),
)
desc_var = cg.new_Pvariable(
descriptor_conf[CONF_ID],
ESPBTUUID_ns.from_raw(descriptor_conf[CONF_UUID]),
max_length,
)
if CONF_VALUE in descriptor_conf:
cg.add(desc_var.set_value(descriptor_value))
cg.add(char_var.add_descriptor(desc_var))
await to_code_characteristic(service_var, char_conf)
cg.add(var.enqueue_start_service(service_var))
cg.add_define("USE_ESP32_BLE_SERVER")
if CORE.using_esp_idf:
@ -348,16 +390,20 @@ async def to_code(config):
cv.Schema(
{
cv.Required(CONF_ID): cv.use_id(BLECharacteristic),
cv.Required(CONF_VALUE): CHARACTERISTIC_VALUE_SCHEMA,
cv.Optional(CONF_BYTE_LENGTH): cv.uint16_t,
cv.GenerateID(CONF_VALUE_BUFFER_): cv.declare_id(ByteBuffer),
cv.Required(CONF_VALUE): VALUE_SCHEMA,
}
),
).extend(VALUE_EXTRAS_SCHEMA),
)
async def ble_server_characteristic_set_value(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
value = await parse_characteristic_value(config[CONF_VALUE], config[CONF_VALUE_BUFFER_], args)
value = await parse_value(
config[CONF_VALUE],
config[CONF_STRING_ENCODING],
config[CONF_VALUE_BUFFER_],
args,
config.get(CONF_BYTE_LENGTH, None),
)
cg.add(var.set_buffer(value))
return var

2
esphome/components/esp32_ble_server/ble_characteristic.cpp
View file

@ -219,7 +219,7 @@ void BLECharacteristic::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt
}
case ESP_GATTS_WRITE_EVT: {
if (this->handle_ != param->write.handle)
return;
break;
if (param->write.is_prep) {
this->value_.insert(this->value_.end(), param->write.value, param->write.value + param->write.len);

20
esphome/components/esp32_ble_server/ble_descriptor.cpp
View file

@ -12,11 +12,17 @@ namespace esp32_ble_server {
static const char *const TAG = "esp32_ble_server.descriptor";
BLEDescriptor::BLEDescriptor(ESPBTUUID uuid, uint16_t max_len) {
BLEDescriptor::BLEDescriptor(ESPBTUUID uuid, uint16_t max_len, bool read, bool write) {
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
if (read) {
this->permissions_ |= ESP_GATT_PERM_READ;
}
if (write) {
this->permissions_ |= ESP_GATT_PERM_WRITE;
}
}
BLEDescriptor::~BLEDescriptor() { free(this->value_.attr_value); } // NOLINT
@ -62,10 +68,14 @@ void BLEDescriptor::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_
break;
}
case ESP_GATTS_WRITE_EVT: {
if (this->handle_ == param->write.handle) {
this->value_.attr_len = param->write.len;
memcpy(this->value_.attr_value, param->write.value, param->write.len);
}
if (this->handle_ != param->write.handle)
break;
this->value_.attr_len = param->write.len;
memcpy(this->value_.attr_value, param->write.value, param->write.len);
this->EventEmitter<BLEDescriptorEvt::VectorEvt, std::vector<uint8_t>>::emit_(
BLEDescriptorEvt::VectorEvt::ON_WRITE,
std::vector<uint8_t>(param->write.value, param->write.value + param->write.len)
);
break;
}
default:

13
esphome/components/esp32_ble_server/ble_descriptor.h
View file

@ -1,6 +1,7 @@
#pragma once
#include "esphome/components/esp32_ble/ble_uuid.h"
#include "esphome/core/event_emitter.h"
#include "esphome/core/bytebuffer.h"
#ifdef USE_ESP32
@ -15,9 +16,15 @@ using namespace esp32_ble;
class BLECharacteristic;
class BLEDescriptor {
namespace BLEDescriptorEvt {
enum VectorEvt {
ON_WRITE,
};
} // namespace BLECharacteristicEvt
class BLEDescriptor : public EventEmitter<BLEDescriptorEvt::VectorEvt, std::vector<uint8_t>> {
public:
BLEDescriptor(ESPBTUUID uuid, uint16_t max_len = 100);
BLEDescriptor(ESPBTUUID uuid, uint16_t max_len = 100, bool read = true, bool write = true);
virtual ~BLEDescriptor();
void do_create(BLECharacteristic *characteristic);
@ -35,7 +42,7 @@ class BLEDescriptor {
esp_attr_value_t value_;
esp_gatt_perm_t permissions_ = ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE;
esp_gatt_perm_t permissions_ = 0;
enum State : uint8_t {
FAILED = 0x00,

11
esphome/components/esp32_ble_server/ble_server_automations.cpp
View file

@ -9,7 +9,7 @@ namespace esp32_ble_server_automations {
using namespace esp32_ble;
Trigger<std::vector<uint8_t>> *BLETriggers::create_on_write_trigger(BLECharacteristic *characteristic) {
Trigger<std::vector<uint8_t>> *BLETriggers::create_characteristic_on_write_trigger(BLECharacteristic *characteristic) {
Trigger<std::vector<uint8_t>> *on_write_trigger = // NOLINT(cppcoreguidelines-owning-memory)
new Trigger<std::vector<uint8_t>>();
characteristic->EventEmitter<BLECharacteristicEvt::VectorEvt, std::vector<uint8_t>>::on(
@ -18,6 +18,15 @@ Trigger<std::vector<uint8_t>> *BLETriggers::create_on_write_trigger(BLECharacter
return on_write_trigger;
}
Trigger<std::vector<uint8_t>> *BLETriggers::create_descriptor_on_write_trigger(BLEDescriptor *descriptor) {
Trigger<std::vector<uint8_t>> *on_write_trigger = // NOLINT(cppcoreguidelines-owning-memory)
new Trigger<std::vector<uint8_t>>();
descriptor->EventEmitter<BLEDescriptorEvt::VectorEvt, std::vector<uint8_t>>::on(
BLEDescriptorEvt::VectorEvt::ON_WRITE,
[on_write_trigger](const std::vector<uint8_t> &data) { on_write_trigger->trigger(data); });
return on_write_trigger;
}
void BLECharacteristicSetValueActionManager::set_listener(BLECharacteristic *characteristic,
EventEmitterListenerID listener_id,
const std::function<void()> &pre_notify_listener) {

3
esphome/components/esp32_ble_server/ble_server_automations.h
View file

@ -21,7 +21,8 @@ using namespace esp32_ble;
class BLETriggers {
public:
static Trigger<std::vector<uint8_t>> *create_on_write_trigger(BLECharacteristic *characteristic);
static Trigger<std::vector<uint8_t>> *create_characteristic_on_write_trigger(BLECharacteristic *characteristic);
static Trigger<std::vector<uint8_t>> *create_descriptor_on_write_trigger(BLEDescriptor *descriptor);
};
enum BLECharacteristicSetValueActionEvt {