sascha/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2025-10-31 15:12:06 +00:00
Code Issues Releases Wiki Activity

Daly BMS improvements (#3388)

Browse Source 
Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com>
Co-authored-by: Samuel Sieb <samuel-github@sieb.net>
This commit is contained in:
matthias882
2023-08-10 07:05:01 +02:00
committed by GitHub
parent 0ed0bdc655
commit 5b0b9da0b9
6 changed files with 217 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
esphome/components/daly_bms/__init__.py
View File

@@ -5,7 +5,6 @@ from esphome.const import CONF_ID, CONF_ADDRESS
CODEOWNERS = ["@s1lvi0"]
DEPENDENCIES = ["uart"]
AUTO_LOAD = ["sensor", "text_sensor", "binary_sensor"]
CONF_BMS_DALY_ID = "bms_daly_id"

5
esphome/components/daly_bms/binary_sensor.py
View File

@@ -27,9 +27,8 @@ CONFIG_SCHEMA = cv.All(
async def setup_conf(config, key, hub):
if key in config:
conf = config[key]
var = await binary_sensor.new_binary_sensor(conf)
if sensor_config := config.get(key):
var = await binary_sensor.new_binary_sensor(sensor_config)
cg.add(getattr(hub, f"set_{key}_binary_sensor")(var))

219
esphome/components/daly_bms/daly_bms.cpp
View File

@@ -1,6 +1,6 @@
#include "daly_bms.h"
#include "esphome/core/log.h"
#include <vector>
#include "esphome/core/log.h"
namespace esphome {
namespace daly_bms {
@@ -19,7 +19,7 @@ static const uint8_t DALY_REQUEST_STATUS = 0x94;
static const uint8_t DALY_REQUEST_CELL_VOLTAGE = 0x95;
static const uint8_t DALY_REQUEST_TEMPERATURE = 0x96;
void DalyBmsComponent::setup() {}
void DalyBmsComponent::setup() { this->next_request_ = 1; }
void DalyBmsComponent::dump_config() {
ESP_LOGCONFIG(TAG, "Daly BMS:");
@@ -27,20 +27,78 @@ void DalyBmsComponent::dump_config() {
}
void DalyBmsComponent::update() {
this->request_data_(DALY_REQUEST_BATTERY_LEVEL);
this->request_data_(DALY_REQUEST_MIN_MAX_VOLTAGE);
this->request_data_(DALY_REQUEST_MIN_MAX_TEMPERATURE);
this->request_data_(DALY_REQUEST_MOS);
this->request_data_(DALY_REQUEST_STATUS);
this->request_data_(DALY_REQUEST_CELL_VOLTAGE);
this->request_data_(DALY_REQUEST_TEMPERATURE);
this->trigger_next_ = true;
this->next_request_ = 0;
}
std::vector<uint8_t> get_battery_level_data;
int available_data = this->available();
if (available_data >= DALY_FRAME_SIZE) {
get_battery_level_data.resize(available_data);
this->read_array(get_battery_level_data.data(), available_data);
this->decode_data_(get_battery_level_data);
void DalyBmsComponent::loop() {
const uint32_t now = millis();
if (this->receiving_ && (now - this->last_transmission_ >= 200)) {
// last transmission too long ago. Reset RX index.
ESP_LOGW(TAG, "Last transmission too long ago. Reset RX index.");
this->data_.clear();
this->receiving_ = false;
}
if ((now - this->last_transmission_ >= 250) && !this->trigger_next_) {
// last transmittion longer than 0.25s ago -> trigger next request
this->last_transmission_ = now;
this->trigger_next_ = true;
}
if (available())
this->last_transmission_ = now;
while (available()) {
uint8_t c;
read_byte(&c);
if (!this->receiving_) {
if (c != 0xa5)
continue;
this->receiving_ = true;
}
this->data_.push_back(c);
if (this->data_.size() == 4)
this->data_count_ = c;
if ((this->data_.size() > 4) and (data_.size() == this->data_count_ + 5)) {
this->decode_data_(this->data_);
this->data_.clear();
this->receiving_ = false;
}
}
if (this->trigger_next_) {
this->trigger_next_ = false;
switch (this->next_request_) {
case 0:
this->request_data_(DALY_REQUEST_BATTERY_LEVEL);
this->next_request_ = 1;
break;
case 1:
this->request_data_(DALY_REQUEST_MIN_MAX_VOLTAGE);
this->next_request_ = 2;
break;
case 2:
this->request_data_(DALY_REQUEST_MIN_MAX_TEMPERATURE);
this->next_request_ = 3;
break;
case 3:
this->request_data_(DALY_REQUEST_MOS);
this->next_request_ = 4;
break;
case 4:
this->request_data_(DALY_REQUEST_STATUS);
this->next_request_ = 5;
break;
case 5:
this->request_data_(DALY_REQUEST_CELL_VOLTAGE);
this->next_request_ = 6;
break;
case 6:
this->request_data_(DALY_REQUEST_TEMPERATURE);
this->next_request_ = 7;
break;
case 7:
default:
break;
}
}
}
@@ -50,7 +108,7 @@ void DalyBmsComponent::request_data_(uint8_t data_id) {
uint8_t request_message[DALY_FRAME_SIZE];
request_message[0] = 0xA5; // Start Flag
request_message[1] = addr_; // Communication Module Address
request_message[1] = this->addr_; // Communication Module Address
request_message[2] = data_id; // Data ID
request_message[3] = 0x08; // Data Length (Fixed)
request_message[4] = 0x00; // Empty Data
@@ -61,9 +119,11 @@ void DalyBmsComponent::request_data_(uint8_t data_id) {
request_message[9] = 0x00; // |
request_message[10] = 0x00; // |
request_message[11] = 0x00; // Empty Data
request_message[12] = (uint8_t) (request_message[0] + request_message[1] + request_message[2] +
request_message[3]); // Checksum (Lower byte of the other bytes sum)
ESP_LOGV(TAG, "Request datapacket Nr %x", data_id);
this->write_array(request_message, sizeof(request_message));
this->flush();
}
@@ -82,6 +142,7 @@ void DalyBmsComponent::decode_data_(std::vector<uint8_t> data) {
if (checksum == it[12]) {
switch (it[2]) {
#ifdef USE_SENSOR
case DALY_REQUEST_BATTERY_LEVEL:
if (this->voltage_sensor_) {
this->voltage_sensor_->publish_state((float) encode_uint16(it[4], it[5]) / 10);
@@ -95,36 +156,37 @@ void DalyBmsComponent::decode_data_(std::vector<uint8_t> data) {
break;
case DALY_REQUEST_MIN_MAX_VOLTAGE:
if (this->max_cell_voltage_) {
this->max_cell_voltage_->publish_state((float) encode_uint16(it[4], it[5]) / 1000);
if (this->max_cell_voltage_sensor_) {
this->max_cell_voltage_sensor_->publish_state((float) encode_uint16(it[4], it[5]) / 1000);
}
if (this->max_cell_voltage_number_) {
this->max_cell_voltage_number_->publish_state(it[6]);
if (this->max_cell_voltage_number_sensor_) {
this->max_cell_voltage_number_sensor_->publish_state(it[6]);
}
if (this->min_cell_voltage_) {
this->min_cell_voltage_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
if (this->min_cell_voltage_sensor_) {
this->min_cell_voltage_sensor_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
}
if (this->min_cell_voltage_number_) {
this->min_cell_voltage_number_->publish_state(it[9]);
if (this->min_cell_voltage_number_sensor_) {
this->min_cell_voltage_number_sensor_->publish_state(it[9]);
}
break;
case DALY_REQUEST_MIN_MAX_TEMPERATURE:
if (this->max_temperature_) {
this->max_temperature_->publish_state(it[4] - DALY_TEMPERATURE_OFFSET);
if (this->max_temperature_sensor_) {
this->max_temperature_sensor_->publish_state(it[4] - DALY_TEMPERATURE_OFFSET);
}
if (this->max_temperature_probe_number_) {
this->max_temperature_probe_number_->publish_state(it[5]);
if (this->max_temperature_probe_number_sensor_) {
this->max_temperature_probe_number_sensor_->publish_state(it[5]);
}
if (this->min_temperature_) {
this->min_temperature_->publish_state(it[6] - DALY_TEMPERATURE_OFFSET);
if (this->min_temperature_sensor_) {
this->min_temperature_sensor_->publish_state(it[6] - DALY_TEMPERATURE_OFFSET);
}
if (this->min_temperature_probe_number_) {
this->min_temperature_probe_number_->publish_state(it[7]);
if (this->min_temperature_probe_number_sensor_) {
this->min_temperature_probe_number_sensor_->publish_state(it[7]);
}
break;
#endif
case DALY_REQUEST_MOS:
#ifdef USE_TEXT_SENSOR
if (this->status_text_sensor_ != nullptr) {
switch (it[4]) {
case 0:
@@ -140,20 +202,27 @@ void DalyBmsComponent::decode_data_(std::vector<uint8_t> data) {
break;
}
}
if (this->charging_mos_enabled_) {
this->charging_mos_enabled_->publish_state(it[5]);
#endif
#ifdef USE_BINARY_SENSOR
if (this->charging_mos_enabled_binary_sensor_) {
this->charging_mos_enabled_binary_sensor_->publish_state(it[5]);
}
if (this->discharging_mos_enabled_) {
this->discharging_mos_enabled_->publish_state(it[6]);
if (this->discharging_mos_enabled_binary_sensor_) {
this->discharging_mos_enabled_binary_sensor_->publish_state(it[6]);
}
if (this->remaining_capacity_) {
this->remaining_capacity_->publish_state((float) encode_uint32(it[8], it[9], it[10], it[11]) / 1000);
#endif
#ifdef USE_SENSOR
if (this->remaining_capacity_sensor_) {
this->remaining_capacity_sensor_->publish_state((float) encode_uint32(it[8], it[9], it[10], it[11]) /
1000);
}
#endif
break;
#ifdef USE_SENSOR
case DALY_REQUEST_STATUS:
if (this->cells_number_) {
this->cells_number_->publish_state(it[4]);
if (this->cells_number_sensor_) {
this->cells_number_sensor_->publish_state(it[4]);
}
break;
@@ -171,71 +240,73 @@ void DalyBmsComponent::decode_data_(std::vector<uint8_t> data) {
case DALY_REQUEST_CELL_VOLTAGE:
switch (it[4]) {
case 1:
if (this->cell_1_voltage_) {
this->cell_1_voltage_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
if (this->cell_1_voltage_sensor_) {
this->cell_1_voltage_sensor_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
}
if (this->cell_2_voltage_) {
this->cell_2_voltage_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
if (this->cell_2_voltage_sensor_) {
this->cell_2_voltage_sensor_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
}
if (this->cell_3_voltage_) {
this->cell_3_voltage_->publish_state((float) encode_uint16(it[9], it[10]) / 1000);
if (this->cell_3_voltage_sensor_) {
this->cell_3_voltage_sensor_->publish_state((float) encode_uint16(it[9], it[10]) / 1000);
}
break;
case 2:
if (this->cell_4_voltage_) {
this->cell_4_voltage_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
if (this->cell_4_voltage_sensor_) {
this->cell_4_voltage_sensor_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
}
if (this->cell_5_voltage_) {
this->cell_5_voltage_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
if (this->cell_5_voltage_sensor_) {
this->cell_5_voltage_sensor_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
}
if (this->cell_6_voltage_) {
this->cell_6_voltage_->publish_state((float) encode_uint16(it[9], it[10]) / 1000);
if (this->cell_6_voltage_sensor_) {
this->cell_6_voltage_sensor_->publish_state((float) encode_uint16(it[9], it[10]) / 1000);
}
break;
case 3:
if (this->cell_7_voltage_) {
this->cell_7_voltage_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
if (this->cell_7_voltage_sensor_) {
this->cell_7_voltage_sensor_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
}
if (this->cell_8_voltage_) {
this->cell_8_voltage_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
if (this->cell_8_voltage_sensor_) {
this->cell_8_voltage_sensor_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
}
if (this->cell_9_voltage_) {
this->cell_9_voltage_->publish_state((float) encode_uint16(it[9], it[10]) / 1000);
if (this->cell_9_voltage_sensor_) {
this->cell_9_voltage_sensor_->publish_state((float) encode_uint16(it[9], it[10]) / 1000);
}
break;
case 4:
if (this->cell_10_voltage_) {
this->cell_10_voltage_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
if (this->cell_10_voltage_sensor_) {
this->cell_10_voltage_sensor_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
}
if (this->cell_11_voltage_) {
this->cell_11_voltage_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
if (this->cell_11_voltage_sensor_) {
this->cell_11_voltage_sensor_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
}
if (this->cell_12_voltage_) {
this->cell_12_voltage_->publish_state((float) encode_uint16(it[9], it[10]) / 1000);
if (this->cell_12_voltage_sensor_) {
this->cell_12_voltage_sensor_->publish_state((float) encode_uint16(it[9], it[10]) / 1000);
}
break;
case 5:
if (this->cell_13_voltage_) {
this->cell_13_voltage_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
if (this->cell_13_voltage_sensor_) {
this->cell_13_voltage_sensor_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
}
if (this->cell_14_voltage_) {
this->cell_14_voltage_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
if (this->cell_14_voltage_sensor_) {
this->cell_14_voltage_sensor_->publish_state((float) encode_uint16(it[7], it[8]) / 1000);
}
if (this->cell_15_voltage_) {
this->cell_15_voltage_->publish_state((float) encode_uint16(it[9], it[10]) / 1000);
if (this->cell_15_voltage_sensor_) {
this->cell_15_voltage_sensor_->publish_state((float) encode_uint16(it[9], it[10]) / 1000);
}
break;
case 6:
if (this->cell_16_voltage_) {
this->cell_16_voltage_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
if (this->cell_16_voltage_sensor_) {
this->cell_16_voltage_sensor_->publish_state((float) encode_uint16(it[5], it[6]) / 1000);
}
break;
}
break;
#endif
default:
break;
}
} else {
ESP_LOGW(TAG, "Checksum-Error on Packet %x", it[4]);
}
std::advance(it, DALY_FRAME_SIZE);
} else {

140
esphome/components/daly_bms/daly_bms.h
View File

@@ -1,9 +1,16 @@
#pragma once
#include "esphome/core/component.h"
#include "esphome/core/defines.h"
#ifdef USE_SENSOR
#include "esphome/components/sensor/sensor.h"
#endif
#ifdef USE_TEXT_SENSOR
#include "esphome/components/text_sensor/text_sensor.h"
#endif
#ifdef USE_BINARY_SENSOR
#include "esphome/components/binary_sensor/binary_sensor.h"
#endif
#include "esphome/components/uart/uart.h"
#include <vector>
@@ -15,60 +22,53 @@ class DalyBmsComponent : public PollingComponent, public uart::UARTDevice {
public:
DalyBmsComponent() = default;
// SENSORS
void set_voltage_sensor(sensor::Sensor *voltage_sensor) { voltage_sensor_ = voltage_sensor; }
void set_current_sensor(sensor::Sensor *current_sensor) { current_sensor_ = current_sensor; }
void set_battery_level_sensor(sensor::Sensor *battery_level_sensor) { battery_level_sensor_ = battery_level_sensor; }
void set_max_cell_voltage_sensor(sensor::Sensor *max_cell_voltage) { max_cell_voltage_ = max_cell_voltage; }
void set_max_cell_voltage_number_sensor(sensor::Sensor *max_cell_voltage_number) {
max_cell_voltage_number_ = max_cell_voltage_number;
}
void set_min_cell_voltage_sensor(sensor::Sensor *min_cell_voltage) { min_cell_voltage_ = min_cell_voltage; }
void set_min_cell_voltage_number_sensor(sensor::Sensor *min_cell_voltage_number) {
min_cell_voltage_number_ = min_cell_voltage_number;
}
void set_max_temperature_sensor(sensor::Sensor *max_temperature) { max_temperature_ = max_temperature; }
void set_max_temperature_probe_number_sensor(sensor::Sensor *max_temperature_probe_number) {
max_temperature_probe_number_ = max_temperature_probe_number;
}
void set_min_temperature_sensor(sensor::Sensor *min_temperature) { min_temperature_ = min_temperature; }
void set_min_temperature_probe_number_sensor(sensor::Sensor *min_temperature_probe_number) {
min_temperature_probe_number_ = min_temperature_probe_number;
}
void set_remaining_capacity_sensor(sensor::Sensor *remaining_capacity) { remaining_capacity_ = remaining_capacity; }
void set_cells_number_sensor(sensor::Sensor *cells_number) { cells_number_ = cells_number; }
void set_temperature_1_sensor(sensor::Sensor *temperature_1_sensor) { temperature_1_sensor_ = temperature_1_sensor; }
void set_temperature_2_sensor(sensor::Sensor *temperature_2_sensor) { temperature_2_sensor_ = temperature_2_sensor; }
void set_cell_1_voltage_sensor(sensor::Sensor *cell_1_voltage) { cell_1_voltage_ = cell_1_voltage; }
void set_cell_2_voltage_sensor(sensor::Sensor *cell_2_voltage) { cell_2_voltage_ = cell_2_voltage; }
void set_cell_3_voltage_sensor(sensor::Sensor *cell_3_voltage) { cell_3_voltage_ = cell_3_voltage; }
void set_cell_4_voltage_sensor(sensor::Sensor *cell_4_voltage) { cell_4_voltage_ = cell_4_voltage; }
void set_cell_5_voltage_sensor(sensor::Sensor *cell_5_voltage) { cell_5_voltage_ = cell_5_voltage; }
void set_cell_6_voltage_sensor(sensor::Sensor *cell_6_voltage) { cell_6_voltage_ = cell_6_voltage; }
void set_cell_7_voltage_sensor(sensor::Sensor *cell_7_voltage) { cell_7_voltage_ = cell_7_voltage; }
void set_cell_8_voltage_sensor(sensor::Sensor *cell_8_voltage) { cell_8_voltage_ = cell_8_voltage; }
void set_cell_9_voltage_sensor(sensor::Sensor *cell_9_voltage) { cell_9_voltage_ = cell_9_voltage; }
void set_cell_10_voltage_sensor(sensor::Sensor *cell_10_voltage) { cell_10_voltage_ = cell_10_voltage; }
void set_cell_11_voltage_sensor(sensor::Sensor *cell_11_voltage) { cell_11_voltage_ = cell_11_voltage; }
void set_cell_12_voltage_sensor(sensor::Sensor *cell_12_voltage) { cell_12_voltage_ = cell_12_voltage; }
void set_cell_13_voltage_sensor(sensor::Sensor *cell_13_voltage) { cell_13_voltage_ = cell_13_voltage; }
void set_cell_14_voltage_sensor(sensor::Sensor *cell_14_voltage) { cell_14_voltage_ = cell_14_voltage; }
void set_cell_15_voltage_sensor(sensor::Sensor *cell_15_voltage) { cell_15_voltage_ = cell_15_voltage; }
void set_cell_16_voltage_sensor(sensor::Sensor *cell_16_voltage) { cell_16_voltage_ = cell_16_voltage; }
#ifdef USE_SENSOR
SUB_SENSOR(voltage)
SUB_SENSOR(current)
SUB_SENSOR(battery_level)
SUB_SENSOR(max_cell_voltage)
SUB_SENSOR(max_cell_voltage_number)
SUB_SENSOR(min_cell_voltage)
SUB_SENSOR(min_cell_voltage_number)
SUB_SENSOR(max_temperature)
SUB_SENSOR(max_temperature_probe_number)
SUB_SENSOR(min_temperature)
SUB_SENSOR(min_temperature_probe_number)
SUB_SENSOR(remaining_capacity)
SUB_SENSOR(cells_number)
SUB_SENSOR(temperature_1)
SUB_SENSOR(temperature_2)
SUB_SENSOR(cell_1_voltage)
SUB_SENSOR(cell_2_voltage)
SUB_SENSOR(cell_3_voltage)
SUB_SENSOR(cell_4_voltage)
SUB_SENSOR(cell_5_voltage)
SUB_SENSOR(cell_6_voltage)
SUB_SENSOR(cell_7_voltage)
SUB_SENSOR(cell_8_voltage)
SUB_SENSOR(cell_9_voltage)
SUB_SENSOR(cell_10_voltage)
SUB_SENSOR(cell_11_voltage)
SUB_SENSOR(cell_12_voltage)
SUB_SENSOR(cell_13_voltage)
SUB_SENSOR(cell_14_voltage)
SUB_SENSOR(cell_15_voltage)
SUB_SENSOR(cell_16_voltage)
#endif
// TEXT_SENSORS
void set_status_text_sensor(text_sensor::TextSensor *status_text_sensor) { status_text_sensor_ = status_text_sensor; }
// BINARY_SENSORS
void set_charging_mos_enabled_binary_sensor(binary_sensor::BinarySensor *charging_mos_enabled) {
charging_mos_enabled_ = charging_mos_enabled;
}
void set_discharging_mos_enabled_binary_sensor(binary_sensor::BinarySensor *discharging_mos_enabled) {
discharging_mos_enabled_ = discharging_mos_enabled;
}
#ifdef USE_TEXT_SENSOR
SUB_TEXT_SENSOR(status)
#endif
#ifdef USE_BINARY_SENSOR
SUB_BINARY_SENSOR(charging_mos_enabled)
SUB_BINARY_SENSOR(discharging_mos_enabled)
#endif
void setup() override;
void dump_config() override;
void update() override;
void loop() override;
float get_setup_priority() const override;
void set_address(uint8_t address) { this->addr_ = address; }
@@ -79,42 +79,12 @@ class DalyBmsComponent : public PollingComponent, public uart::UARTDevice {
uint8_t addr_;
sensor::Sensor *voltage_sensor_{nullptr};
sensor::Sensor *current_sensor_{nullptr};
sensor::Sensor *battery_level_sensor_{nullptr};
sensor::Sensor *max_cell_voltage_{nullptr};
sensor::Sensor *max_cell_voltage_number_{nullptr};
sensor::Sensor *min_cell_voltage_{nullptr};
sensor::Sensor *min_cell_voltage_number_{nullptr};
sensor::Sensor *max_temperature_{nullptr};
sensor::Sensor *max_temperature_probe_number_{nullptr};
sensor::Sensor *min_temperature_{nullptr};
sensor::Sensor *min_temperature_probe_number_{nullptr};
sensor::Sensor *remaining_capacity_{nullptr};
sensor::Sensor *cells_number_{nullptr};
sensor::Sensor *temperature_1_sensor_{nullptr};
sensor::Sensor *temperature_2_sensor_{nullptr};
sensor::Sensor *cell_1_voltage_{nullptr};
sensor::Sensor *cell_2_voltage_{nullptr};
sensor::Sensor *cell_3_voltage_{nullptr};
sensor::Sensor *cell_4_voltage_{nullptr};
sensor::Sensor *cell_5_voltage_{nullptr};
sensor::Sensor *cell_6_voltage_{nullptr};
sensor::Sensor *cell_7_voltage_{nullptr};
sensor::Sensor *cell_8_voltage_{nullptr};
sensor::Sensor *cell_9_voltage_{nullptr};
sensor::Sensor *cell_10_voltage_{nullptr};
sensor::Sensor *cell_11_voltage_{nullptr};
sensor::Sensor *cell_12_voltage_{nullptr};
sensor::Sensor *cell_13_voltage_{nullptr};
sensor::Sensor *cell_14_voltage_{nullptr};
sensor::Sensor *cell_15_voltage_{nullptr};
sensor::Sensor *cell_16_voltage_{nullptr};
text_sensor::TextSensor *status_text_sensor_{nullptr};
binary_sensor::BinarySensor *charging_mos_enabled_{nullptr};
binary_sensor::BinarySensor *discharging_mos_enabled_{nullptr};
std::vector<uint8_t> data_;
bool receiving_{false};
uint8_t data_count_;
uint32_t last_transmission_{0};
bool trigger_next_;
uint8_t next_request_;
};
} // namespace daly_bms

5
esphome/components/daly_bms/sensor.py
View File

@@ -218,9 +218,8 @@ CONFIG_SCHEMA = cv.All(
async def setup_conf(config, key, hub):
if key in config:
conf = config[key]
sens = await sensor.new_sensor(conf)
if sensor_config := config.get(key):
sens = await sensor.new_sensor(sensor_config)
cg.add(getattr(hub, f"set_{key}_sensor")(sens))

5
esphome/components/daly_bms/text_sensor.py
View File

@@ -23,9 +23,8 @@ CONFIG_SCHEMA = cv.All(
async def setup_conf(config, key, hub):
if key in config:
conf = config[key]
sens = await text_sensor.new_text_sensor(conf)
if sensor_config := config.get(key):
sens = await text_sensor.new_text_sensor(sensor_config)
cg.add(getattr(hub, f"set_{key}_text_sensor")(sens))