sascha/esphome
1
0
Fork 0
mirror of https://github.com/esphome/esphome.git synced 2025-09-03 03:42:20 +01:00
Code Issues Releases Wiki Activity

Merge branch 'dev' into integration

Browse Source
This commit is contained in:
J. Nick Koston
2025-08-19 21:43:09 -05:00
parent 9554c82c0b 0089619518
commit f0da3d6c09
38 changed files with 544 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
.github/workflows/auto-label-pr.yml vendored
View File

@@ -105,7 +105,9 @@ jobs:
// Calculate data from PR files
const changedFiles = prFiles.map(file => file.filename);
const totalChanges = prFiles.reduce((sum, file) => sum + (file.additions || 0) + (file.deletions || 0), 0);
const totalAdditions = prFiles.reduce((sum, file) => sum + (file.additions || 0), 0);
const totalDeletions = prFiles.reduce((sum, file) => sum + (file.deletions || 0), 0);
const totalChanges = totalAdditions + totalDeletions;
console.log('Current labels:', currentLabels.join(', '));
console.log('Changed files:', changedFiles.length);
@@ -231,16 +233,21 @@ jobs:
// Strategy: PR size detection
async function detectPRSize() {
const labels = new Set();
const testChanges = prFiles
.filter(file => file.filename.startsWith('tests/'))
.reduce((sum, file) => sum + (file.additions || 0) + (file.deletions || 0), 0);
const nonTestChanges = totalChanges - testChanges;
if (totalChanges <= SMALL_PR_THRESHOLD) {
labels.add('small-pr');
return labels;
}
const testAdditions = prFiles
.filter(file => file.filename.startsWith('tests/'))
.reduce((sum, file) => sum + (file.additions || 0), 0);
const testDeletions = prFiles
.filter(file => file.filename.startsWith('tests/'))
.reduce((sum, file) => sum + (file.deletions || 0), 0);
const nonTestChanges = (totalAdditions - testAdditions) - (totalDeletions - testDeletions);
// Don't add too-big if mega-pr label is already present
if (nonTestChanges > TOO_BIG_THRESHOLD && !isMegaPR) {
labels.add('too-big');
@@ -412,10 +419,13 @@ jobs:
// Too big message
if (finalLabels.includes('too-big')) {
const testChanges = prFiles
const testAdditions = prFiles
.filter(file => file.filename.startsWith('tests/'))
.reduce((sum, file) => sum + (file.additions || 0) + (file.deletions || 0), 0);
const nonTestChanges = totalChanges - testChanges;
.reduce((sum, file) => sum + (file.additions || 0), 0);
const testDeletions = prFiles
.filter(file => file.filename.startsWith('tests/'))
.reduce((sum, file) => sum + (file.deletions || 0), 0);
const nonTestChanges = (totalAdditions - testAdditions) - (totalDeletions - testDeletions);
const tooManyLabels = finalLabels.length > MAX_LABELS;
const tooManyChanges = nonTestChanges > TOO_BIG_THRESHOLD;

21
esphome/components/ags10/ags10.cpp
View File

@@ -89,7 +89,7 @@ void AGS10Component::dump_config() {
bool AGS10Component::new_i2c_address(uint8_t newaddress) {
uint8_t rev_newaddress = ~newaddress;
std::array<uint8_t, 5> data{newaddress, rev_newaddress, newaddress, rev_newaddress, 0};
data[4] = calc_crc8_(data, 4);
data[4] = crc8(data.data(), 4, 0xFF, 0x31, true);
if (!this->write_bytes(REG_ADDRESS, data)) {
this->error_code_ = COMMUNICATION_FAILED;
this->status_set_warning();
@@ -109,7 +109,7 @@ bool AGS10Component::set_zero_point_with_current_resistance() { return this->set
bool AGS10Component::set_zero_point_with(uint16_t value) {
std::array<uint8_t, 5> data{0x00, 0x0C, (uint8_t) ((value >> 8) & 0xFF), (uint8_t) (value & 0xFF), 0};
data[4] = calc_crc8_(data, 4);
data[4] = crc8(data.data(), 4, 0xFF, 0x31, true);
if (!this->write_bytes(REG_CALIBRATION, data)) {
this->error_code_ = COMMUNICATION_FAILED;
this->status_set_warning();
@@ -184,7 +184,7 @@ template<size_t N> optional<std::array<uint8_t, N>> AGS10Component::read_and_che
auto res = *data;
auto crc_byte = res[len];
if (crc_byte != calc_crc8_(res, len)) {
if (crc_byte != crc8(res.data(), len, 0xFF, 0x31, true)) {
this->error_code_ = CRC_CHECK_FAILED;
ESP_LOGE(TAG, "Reading AGS10 version failed: crc error!");
return optional<std::array<uint8_t, N>>();
@@ -192,20 +192,5 @@ template<size_t N> optional<std::array<uint8_t, N>> AGS10Component::read_and_che
return data;
}
template<size_t N> uint8_t AGS10Component::calc_crc8_(std::array<uint8_t, N> dat, uint8_t num) {
uint8_t i, byte1, crc = 0xFF;
for (byte1 = 0; byte1 < num; byte1++) {
crc ^= (dat[byte1]);
for (i = 0; i < 8; i++) {
if (crc & 0x80) {
crc = (crc << 1) ^ 0x31;
} else {
crc = (crc << 1);
}
}
}
return crc;
}
} // namespace ags10
} // namespace esphome

14
esphome/components/ags10/ags10.h
View File

@@ -1,9 +1,9 @@
#pragma once
#include "esphome/components/i2c/i2c.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/core/automation.h"
#include "esphome/core/component.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/components/i2c/i2c.h"
namespace esphome {
namespace ags10 {
@@ -99,16 +99,6 @@ class AGS10Component : public PollingComponent, public i2c::I2CDevice {
* Read, checks and returns data from the sensor.
*/
template<size_t N> optional<std::array<uint8_t, N>> read_and_check_(uint8_t a_register);
/**
* Calculates CRC8 value.
*
* CRC8 calculation, initial value: 0xFF, polynomial: 0x31 (x8+ x5+ x4+1)
*
* @param[in] dat the data buffer
* @param num number of bytes in the buffer
*/
template<size_t N> uint8_t calc_crc8_(std::array<uint8_t, N> dat, uint8_t num);
};
template<typename... Ts> class AGS10NewI2cAddressAction : public Action<Ts...>, public Parented<AGS10Component> {

4
esphome/components/airthings_ble/__init__.py
View File

@@ -18,6 +18,6 @@ CONFIG_SCHEMA = cv.Schema(
).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
def to_code(config):
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield esp32_ble_tracker.register_ble_device(var, config)
await esp32_ble_tracker.register_ble_device(var, config)

18
esphome/components/am2315c/am2315c.cpp
View File

@@ -29,22 +29,6 @@ namespace am2315c {
static const char *const TAG = "am2315c";
uint8_t AM2315C::crc8_(uint8_t *data, uint8_t len) {
uint8_t crc = 0xFF;
while (len--) {
crc ^= *data++;
for (uint8_t i = 0; i < 8; i++) {
if (crc & 0x80) {
crc <<= 1;
crc ^= 0x31;
} else {
crc <<= 1;
}
}
}
return crc;
}
bool AM2315C::reset_register_(uint8_t reg) {
// code based on demo code sent by www.aosong.com
// no further documentation.
@@ -86,7 +70,7 @@ bool AM2315C::convert_(uint8_t *data, float &humidity, float &temperature) {
humidity = raw * 9.5367431640625e-5;
raw = ((data[3] & 0x0F) << 16) | (data[4] << 8) | data[5];
temperature = raw * 1.9073486328125e-4 - 50;
return this->crc8_(data, 6) == data[6];
return crc8(data, 6, 0xFF, 0x31, true) == data[6];
}
void AM2315C::setup() {

5
esphome/components/am2315c/am2315c.h
View File

@@ -21,9 +21,9 @@
// SOFTWARE.
#pragma once
#include "esphome/core/component.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/components/i2c/i2c.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/core/component.h"
namespace esphome {
namespace am2315c {
@@ -39,7 +39,6 @@ class AM2315C : public PollingComponent, public i2c::I2CDevice {
void set_humidity_sensor(sensor::Sensor *humidity_sensor) { this->humidity_sensor_ = humidity_sensor; }
protected:
uint8_t crc8_(uint8_t *data, uint8_t len);
bool convert_(uint8_t *data, float &humidity, float &temperature);
bool reset_register_(uint8_t reg);

2
esphome/components/binary_sensor/binary_sensor.h
View File

@@ -10,11 +10,9 @@ namespace esphome {
namespace binary_sensor {
// Forward declaration
class BinarySensor;
void log_binary_sensor(const char *tag, const char *prefix, const char *type, BinarySensor *obj);
// Macro that calls the function - kept for backward compatibility
#define LOG_BINARY_SENSOR(prefix, type, obj) log_binary_sensor(TAG, prefix, LOG_STR_LITERAL(type), obj)
#define SUB_BINARY_SENSOR(name) \

8
esphome/components/ble_client/output/__init__.py
View File

@@ -27,7 +27,7 @@ CONFIG_SCHEMA = cv.All(
)
def to_code(config):
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
cg.add(
@@ -63,6 +63,6 @@ def to_code(config):
)
cg.add(var.set_char_uuid128(uuid128))
cg.add(var.set_require_response(config[CONF_REQUIRE_RESPONSE]))
yield output.register_output(var, config)
yield ble_client.register_ble_node(var, config)
yield cg.register_component(var, config)
await output.register_output(var, config)
await ble_client.register_ble_node(var, config)
await cg.register_component(var, config)

2
esphome/components/button/button.h
View File

@@ -7,11 +7,9 @@
namespace esphome {
namespace button {
// Forward declaration
class Button;
void log_button(const char *tag, const char *prefix, const char *type, Button *obj);
// Macro that calls the function - kept for backward compatibility
#define LOG_BUTTON(prefix, type, obj) log_button(TAG, prefix, LOG_STR_LITERAL(type), obj)
#define SUB_BUTTON(name) \

6
esphome/components/cover/__init__.py
View File

@@ -228,9 +228,9 @@ async def cover_stop_to_code(config, action_id, template_arg, args):
@automation.register_action("cover.toggle", ToggleAction, COVER_ACTION_SCHEMA)
def cover_toggle_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
async def cover_toggle_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
COVER_CONTROL_ACTION_SCHEMA = cv.Schema(

24
esphome/components/hte501/hte501.cpp
View File

@@ -12,7 +12,7 @@ void HTE501Component::setup() {
this->write(address, 2, false);
uint8_t identification[9];
this->read(identification, 9);
if (identification[8] != calc_crc8_(identification, 0, 7)) {
if (identification[8] != crc8(identification, 8, 0xFF, 0x31, true)) {
this->error_code_ = CRC_CHECK_FAILED;
this->mark_failed();
return;
@@ -46,7 +46,8 @@ void HTE501Component::update() {
this->set_timeout(50, [this]() {
uint8_t i2c_response[6];
this->read(i2c_response, 6);
if (i2c_response[2] != calc_crc8_(i2c_response, 0, 1) && i2c_response[5] != calc_crc8_(i2c_response, 3, 4)) {
if (i2c_response[2] != crc8(i2c_response, 2, 0xFF, 0x31, true) &&
i2c_response[5] != crc8(i2c_response + 3, 2, 0xFF, 0x31, true)) {
this->error_code_ = CRC_CHECK_FAILED;
this->status_set_warning();
return;
@@ -67,24 +68,5 @@ void HTE501Component::update() {
this->status_clear_warning();
});
}
unsigned char HTE501Component::calc_crc8_(const unsigned char buf[], unsigned char from, unsigned char to) {
unsigned char crc_val = 0xFF;
unsigned char i = 0;
unsigned char j = 0;
for (i = from; i <= to; i++) {
int cur_val = buf[i];
for (j = 0; j < 8; j++) {
if (((crc_val ^ cur_val) & 0x80) != 0) // If MSBs are not equal
{
crc_val = ((crc_val << 1) ^ 0x31);
} else {
crc_val = (crc_val << 1);
}
cur_val = cur_val << 1;
}
}
return crc_val;
}
} // namespace hte501
} // namespace esphome

5
esphome/components/hte501/hte501.h
View File

@@ -1,8 +1,8 @@
#pragma once
#include "esphome/core/component.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/components/i2c/i2c.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/core/component.h"
namespace esphome {
namespace hte501 {
@@ -19,7 +19,6 @@ class HTE501Component : public PollingComponent, public i2c::I2CDevice {
void update() override;
protected:
unsigned char calc_crc8_(const unsigned char buf[], unsigned char from, unsigned char to);
sensor::Sensor *temperature_sensor_;
sensor::Sensor *humidity_sensor_;

21
esphome/components/lc709203f/lc709203f.cpp
View File

@@ -1,5 +1,6 @@
#include "esphome/core/log.h"
#include "lc709203f.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
namespace esphome {
namespace lc709203f {
@@ -189,7 +190,7 @@ uint8_t Lc709203f::get_register_(uint8_t register_to_read, uint16_t *register_va
// Error on the i2c bus
this->status_set_warning(
str_sprintf("Error code %d when reading from register 0x%02X", return_code, register_to_read).c_str());
} else if (this->crc8_(read_buffer, 5) != read_buffer[5]) {
} else if (crc8(read_buffer, 5, 0x00, 0x07, true) != read_buffer[5]) {
// I2C indicated OK, but the CRC of the data does not matcth.
this->status_set_warning(str_sprintf("CRC error reading from register 0x%02X", register_to_read).c_str());
} else {
@@ -220,7 +221,7 @@ uint8_t Lc709203f::set_register_(uint8_t register_to_set, uint16_t value_to_set)
write_buffer[1] = register_to_set;
write_buffer[2] = value_to_set & 0xFF; // Low byte
write_buffer[3] = (value_to_set >> 8) & 0xFF; // High byte
write_buffer[4] = this->crc8_(write_buffer, 4);
write_buffer[4] = crc8(write_buffer, 4, 0x00, 0x07, true);
for (uint8_t i = 0; i <= LC709203F_I2C_RETRY_COUNT; i++) {
// Note: we don't write the first byte of the write buffer to the device.
@@ -239,20 +240,6 @@ uint8_t Lc709203f::set_register_(uint8_t register_to_set, uint16_t value_to_set)
return return_code;
}
uint8_t Lc709203f::crc8_(uint8_t *byte_buffer, uint8_t length_of_crc) {
uint8_t crc = 0x00;
const uint8_t polynomial(0x07);
for (uint8_t j = length_of_crc; j; --j) {
crc ^= *byte_buffer++;
for (uint8_t i = 8; i; --i) {
crc = (crc & 0x80) ? (crc << 1) ^ polynomial : (crc << 1);
}
}
return crc;
}
void Lc709203f::set_pack_size(uint16_t pack_size) {
static const uint16_t PACK_SIZE_ARRAY[6] = {100, 200, 500, 1000, 2000, 3000};
static const uint16_t APA_ARRAY[6] = {0x08, 0x0B, 0x10, 0x19, 0x2D, 0x36};

5
esphome/components/lc709203f/lc709203f.h
View File

@@ -1,8 +1,8 @@
#pragma once
#include "esphome/core/component.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/components/i2c/i2c.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/core/component.h"
namespace esphome {
namespace lc709203f {
@@ -38,7 +38,6 @@ class Lc709203f : public sensor::Sensor, public PollingComponent, public i2c::I2
private:
uint8_t get_register_(uint8_t register_to_read, uint16_t *register_value);
uint8_t set_register_(uint8_t register_to_set, uint16_t value_to_set);
uint8_t crc8_(uint8_t *byte_buffer, uint8_t length_of_crc);
protected:
sensor::Sensor *voltage_sensor_{nullptr};

7
esphome/components/light/addressable_light_effect.h
View File

@@ -44,6 +44,13 @@ class AddressableLightEffect : public LightEffect {
this->apply(*this->get_addressable_(), current_color);
}
/// Get effect index specifically for addressable effects.
/// Can be used by effects to modify behavior based on their position in the list.
uint32_t get_effect_index() const { return this->get_index(); }
/// Check if this is the currently running addressable effect.
bool is_current_effect() const { return this->is_active() && this->get_addressable_()->is_effect_active(); }
protected:
AddressableLight *get_addressable_() const { return (AddressableLight *) this->state_->get_output(); }
};

8
esphome/components/light/base_light_effects.h
View File

@@ -125,6 +125,10 @@ class LambdaLightEffect : public LightEffect {
}
}
/// Get the current effect index for use in lambda functions.
/// This can be useful for lambda effects that need to know their own index.
uint32_t get_current_index() const { return this->get_index(); }
protected:
std::function<void(bool initial_run)> f_;
uint32_t update_interval_;
@@ -143,6 +147,10 @@ class AutomationLightEffect : public LightEffect {
}
Trigger<> *get_trig() const { return trig_; }
/// Get the current effect index for use in automations.
/// Useful for automations that need to know which effect is running.
uint32_t get_current_index() const { return this->get_index(); }
protected:
Trigger<> *trig_{new Trigger<>};
};

36
esphome/components/light/light_effect.cpp Normal file
View File

@@ -0,0 +1,36 @@
#include "light_effect.h"
#include "light_state.h"
namespace esphome {
namespace light {
uint32_t LightEffect::get_index() const {
if (this->state_ == nullptr) {
return 0;
}
return this->get_index_in_parent_();
}
bool LightEffect::is_active() const {
if (this->state_ == nullptr) {
return false;
}
return this->get_index() != 0 && this->state_->get_current_effect_index() == this->get_index();
}
uint32_t LightEffect::get_index_in_parent_() const {
if (this->state_ == nullptr) {
return 0;
}
const auto &effects = this->state_->get_effects();
for (size_t i = 0; i < effects.size(); i++) {
if (effects[i] == this) {
return i + 1; // Effects are 1-indexed in the API
}
}
return 0; // Not found
}
} // namespace light
} // namespace esphome

14
esphome/components/light/light_effect.h
View File

@@ -34,9 +34,23 @@ class LightEffect {
this->init();
}
/// Get the index of this effect in the parent light's effect list.
/// Returns 0 if not found or not initialized.
uint32_t get_index() const;
/// Check if this effect is currently active.
bool is_active() const;
/// Get a reference to the parent light state.
/// Returns nullptr if not initialized.
LightState *get_light_state() const { return this->state_; }
protected:
LightState *state_{nullptr};
std::string name_;
/// Internal method to find this effect's index in the parent light's effect list.
uint32_t get_index_in_parent_() const;
};
} // namespace light

10
esphome/components/light/light_json_schema.cpp
View File

@@ -36,8 +36,11 @@ static constexpr const char *get_color_mode_json_str(ColorMode mode) {
void LightJSONSchema::dump_json(LightState &state, JsonObject root) {
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks) false positive with ArduinoJson
if (state.supports_effects())
if (state.supports_effects()) {
root["effect"] = state.get_effect_name();
root["effect_index"] = state.get_current_effect_index();
root["effect_count"] = state.get_effect_count();
}
auto values = state.remote_values;
auto traits = state.get_output()->get_traits();
@@ -160,6 +163,11 @@ void LightJSONSchema::parse_json(LightState &state, LightCall &call, JsonObject
const char *effect = root["effect"];
call.set_effect(effect);
}
if (root["effect_index"].is<uint32_t>()) {
uint32_t effect_index = root["effect_index"];
call.set_effect(effect_index);
}
}
} // namespace light

38
esphome/components/light/light_state.h
View File

@@ -163,6 +163,44 @@ class LightState : public EntityBase, public Component {
/// Add effects for this light state.
void add_effects(const std::vector<LightEffect *> &effects);
/// Get the total number of effects available for this light.
size_t get_effect_count() const { return this->effects_.size(); }
/// Get the currently active effect index (0 = no effect, 1+ = effect index).
uint32_t get_current_effect_index() const { return this->active_effect_index_; }
/// Get effect index by name. Returns 0 if effect not found.
uint32_t get_effect_index(const std::string &effect_name) const {
if (strcasecmp(effect_name.c_str(), "none") == 0) {
return 0;
}
for (size_t i = 0; i < this->effects_.size(); i++) {
if (strcasecmp(effect_name.c_str(), this->effects_[i]->get_name().c_str()) == 0) {
return i + 1; // Effects are 1-indexed in active_effect_index_
}
}
return 0; // Effect not found
}
/// Get effect by index. Returns nullptr if index is invalid.
LightEffect *get_effect_by_index(uint32_t index) const {
if (index == 0 || index > this->effects_.size()) {
return nullptr;
}
return this->effects_[index - 1]; // Effects are 1-indexed in active_effect_index_
}
/// Get effect name by index. Returns "None" for index 0, empty string for invalid index.
std::string get_effect_name_by_index(uint32_t index) const {
if (index == 0) {
return "None";
}
if (index > this->effects_.size()) {
return ""; // Invalid index
}
return this->effects_[index - 1]->get_name();
}
/// The result of all the current_values_as_* methods have gamma correction applied.
void current_values_as_binary(bool *binary);

17
esphome/components/mlx90614/mlx90614.cpp
View File

@@ -50,28 +50,13 @@ bool MLX90614Component::write_emissivity_() {
return true;
}
uint8_t MLX90614Component::crc8_pec_(const uint8_t *data, uint8_t len) {
uint8_t crc = 0;
for (uint8_t i = 0; i < len; i++) {
uint8_t in = data[i];
for (uint8_t j = 0; j < 8; j++) {
bool carry = (crc ^ in) & 0x80;
crc <<= 1;
if (carry)
crc ^= 0x07;
in <<= 1;
}
}
return crc;
}
bool MLX90614Component::write_bytes_(uint8_t reg, uint16_t data) {
uint8_t buf[5];
buf[0] = this->address_ << 1;
buf[1] = reg;
buf[2] = data & 0xFF;
buf[3] = data >> 8;
buf[4] = this->crc8_pec_(buf, 4);
buf[4] = crc8(buf, 4, 0x00, 0x07, true);
return this->write_bytes(reg, buf + 2, 3);
}

1
esphome/components/mlx90614/mlx90614.h
View File

@@ -22,7 +22,6 @@ class MLX90614Component : public PollingComponent, public i2c::I2CDevice {
protected:
bool write_emissivity_();
uint8_t crc8_pec_(const uint8_t *data, uint8_t len);
bool write_bytes_(uint8_t reg, uint16_t data);
sensor::Sensor *ambient_sensor_{nullptr};

2
esphome/components/number/number.h
View File

@@ -9,11 +9,9 @@
namespace esphome {
namespace number {
// Forward declaration
class Number;
void log_number(const char *tag, const char *prefix, const char *type, Number *obj);
// Macro that calls the function - kept for backward compatibility
#define LOG_NUMBER(prefix, type, obj) log_number(TAG, prefix, LOG_STR_LITERAL(type), obj)
#define SUB_NUMBER(name) \

6
esphome/components/pipsolar/__init__.py
View File

@@ -26,7 +26,7 @@ CONFIG_SCHEMA = cv.All(
)
def to_code(config):
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield cg.register_component(var, config)
yield uart.register_uart_device(var, config)
await cg.register_component(var, config)
await uart.register_uart_device(var, config)

8
esphome/components/pipsolar/output/__init__.py
View File

@@ -99,9 +99,9 @@ async def to_code(config):
}
),
)
def output_pipsolar_set_level_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
async def output_pipsolar_set_level_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
var = cg.new_Pvariable(action_id, template_arg, paren)
template_ = yield cg.templatable(config[CONF_VALUE], args, float)
template_ = await cg.templatable(config[CONF_VALUE], args, float)
cg.add(var.set_level(template_))
yield var
return var

4
esphome/components/radon_eye_ble/__init__.py
View File

@@ -18,6 +18,6 @@ CONFIG_SCHEMA = cv.Schema(
).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA)
def to_code(config):
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
yield esp32_ble_tracker.register_ble_device(var, config)
await esp32_ble_tracker.register_ble_device(var, config)

14
esphome/components/remote_base/__init__.py
View File

@@ -1782,14 +1782,12 @@ def nexa_dumper(var, config):
@register_action("nexa", NexaAction, NEXA_SCHEMA)
def nexa_action(var, config, args):
cg.add(var.set_device((yield cg.templatable(config[CONF_DEVICE], args, cg.uint32))))
cg.add(var.set_group((yield cg.templatable(config[CONF_GROUP], args, cg.uint8))))
cg.add(var.set_state((yield cg.templatable(config[CONF_STATE], args, cg.uint8))))
cg.add(
var.set_channel((yield cg.templatable(config[CONF_CHANNEL], args, cg.uint8)))
)
cg.add(var.set_level((yield cg.templatable(config[CONF_LEVEL], args, cg.uint8))))
async def nexa_action(var, config, args):
cg.add(var.set_device(await cg.templatable(config[CONF_DEVICE], args, cg.uint32)))
cg.add(var.set_group(await cg.templatable(config[CONF_GROUP], args, cg.uint8)))
cg.add(var.set_state(await cg.templatable(config[CONF_STATE], args, cg.uint8)))
cg.add(var.set_channel(await cg.templatable(config[CONF_CHANNEL], args, cg.uint8)))
cg.add(var.set_level(await cg.templatable(config[CONF_LEVEL], args, cg.uint8)))
# Midea

14
esphome/components/shelly_dimmer/light.py
View File

@@ -183,7 +183,7 @@ CONFIG_SCHEMA = (
)
def to_code(config):
async def to_code(config):
fw_hex = get_firmware(config[CONF_FIRMWARE])
fw_major, fw_minor = parse_firmware_version(config[CONF_FIRMWARE][CONF_VERSION])
@@ -193,17 +193,17 @@ def to_code(config):
cg.add_define("USE_SHD_FIRMWARE_MINOR_VERSION", fw_minor)
var = cg.new_Pvariable(config[CONF_OUTPUT_ID])
yield cg.register_component(var, config)
await cg.register_component(var, config)
config.pop(
CONF_UPDATE_INTERVAL
) # drop UPDATE_INTERVAL as it does not apply to the light component
yield light.register_light(var, config)
yield uart.register_uart_device(var, config)
await light.register_light(var, config)
await uart.register_uart_device(var, config)
nrst_pin = yield cg.gpio_pin_expression(config[CONF_NRST_PIN])
nrst_pin = await cg.gpio_pin_expression(config[CONF_NRST_PIN])
cg.add(var.set_nrst_pin(nrst_pin))
boot0_pin = yield cg.gpio_pin_expression(config[CONF_BOOT0_PIN])
boot0_pin = await cg.gpio_pin_expression(config[CONF_BOOT0_PIN])
cg.add(var.set_boot0_pin(boot0_pin))
cg.add(var.set_leading_edge(config[CONF_LEADING_EDGE]))
@@ -217,5 +217,5 @@ def to_code(config):
continue
conf = config[key]
sens = yield sensor.new_sensor(conf)
sens = await sensor.new_sensor(conf)
cg.add(getattr(var, f"set_{key}_sensor")(sens))

23
esphome/components/tee501/tee501.cpp
View File

@@ -12,7 +12,7 @@ void TEE501Component::setup() {
this->write(address, 2, false);
uint8_t identification[9];
this->read(identification, 9);
if (identification[8] != calc_crc8_(identification, 0, 7)) {
if (identification[8] != crc8(identification, 8, 0xFF, 0x31, true)) {
this->error_code_ = CRC_CHECK_FAILED;
this->mark_failed();
return;
@@ -45,7 +45,7 @@ void TEE501Component::update() {
this->set_timeout(50, [this]() {
uint8_t i2c_response[3];
this->read(i2c_response, 3);
if (i2c_response[2] != calc_crc8_(i2c_response, 0, 1)) {
if (i2c_response[2] != crc8(i2c_response, 2, 0xFF, 0x31, true)) {
this->error_code_ = CRC_CHECK_FAILED;
this->status_set_warning();
return;
@@ -62,24 +62,5 @@ void TEE501Component::update() {
});
}
unsigned char TEE501Component::calc_crc8_(const unsigned char buf[], unsigned char from, unsigned char to) {
unsigned char crc_val = 0xFF;
unsigned char i = 0;
unsigned char j = 0;
for (i = from; i <= to; i++) {
int cur_val = buf[i];
for (j = 0; j < 8; j++) {
if (((crc_val ^ cur_val) & 0x80) != 0) // If MSBs are not equal
{
crc_val = ((crc_val << 1) ^ 0x31);
} else {
crc_val = (crc_val << 1);
}
cur_val = cur_val << 1;
}
}
return crc_val;
}
} // namespace tee501
} // namespace esphome

6
esphome/components/tee501/tee501.h
View File

@@ -1,8 +1,8 @@
#pragma once
#include "esphome/core/component.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/components/i2c/i2c.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/core/component.h"
namespace esphome {
namespace tee501 {
@@ -16,8 +16,6 @@ class TEE501Component : public sensor::Sensor, public PollingComponent, public i
void update() override;
protected:
unsigned char calc_crc8_(const unsigned char buf[], unsigned char from, unsigned char to);
enum ErrorCode { NONE = 0, COMMUNICATION_FAILED, CRC_CHECK_FAILED } error_code_{NONE};
};

6
esphome/components/valve/__init__.py
View File

@@ -202,9 +202,9 @@ async def valve_stop_to_code(config, action_id, template_arg, args):
@automation.register_action("valve.toggle", ToggleAction, VALVE_ACTION_SCHEMA)
def valve_toggle_to_code(config, action_id, template_arg, args):
paren = yield cg.get_variable(config[CONF_ID])
yield cg.new_Pvariable(action_id, template_arg, paren)
async def valve_toggle_to_code(config, action_id, template_arg, args):
paren = await cg.get_variable(config[CONF_ID])
return cg.new_Pvariable(action_id, template_arg, paren)
VALVE_CONTROL_ACTION_SCHEMA = cv.Schema(

29
esphome/core/helpers.cpp
View File

@@ -41,17 +41,28 @@ static const uint16_t CRC16_1021_BE_LUT_H[] = {0x0000, 0x1231, 0x2462, 0x3653, 0
// Mathematics
uint8_t crc8(const uint8_t *data, uint8_t len) {
uint8_t crc = 0;
uint8_t crc8(const uint8_t *data, uint8_t len, uint8_t crc, uint8_t poly, bool msb_first) {
while ((len--) != 0u) {
uint8_t inbyte = *data++;
for (uint8_t i = 8; i != 0u; i--) {
bool mix = (crc ^ inbyte) & 0x01;
crc >>= 1;
if (mix)
crc ^= 0x8C;
inbyte >>= 1;
if (msb_first) {
// MSB first processing (for polynomials like 0x31, 0x07)
crc ^= inbyte;
for (uint8_t i = 8; i != 0u; i--) {
if (crc & 0x80) {
crc = (crc << 1) ^ poly;
} else {
crc <<= 1;
}
}
} else {
// LSB first processing (default for Dallas/Maxim 0x8C)
for (uint8_t i = 8; i != 0u; i--) {
bool mix = (crc ^ inbyte) & 0x01;
crc >>= 1;
if (mix)
crc ^= poly;
inbyte >>= 1;
}
}
}
return crc;

4
esphome/core/helpers.h
View File

@@ -145,8 +145,8 @@ template<typename T, typename U> T remap(U value, U min, U max, T min_out, T max
return (value - min) * (max_out - min_out) / (max - min) + min_out;
}
/// Calculate a CRC-8 checksum of \p data with size \p len using the CRC-8-Dallas/Maxim polynomial.
uint8_t crc8(const uint8_t *data, uint8_t len);
/// Calculate a CRC-8 checksum of \p data with size \p len.
uint8_t crc8(const uint8_t *data, uint8_t len, uint8_t crc = 0x00, uint8_t poly = 0x8C, bool msb_first = false);
/// Calculate a CRC-16 checksum of \p data with size \p len.
uint16_t crc16(const uint8_t *data, uint16_t len, uint16_t crc = 0xffff, uint16_t reverse_poly = 0xa001,

17
tests/integration/fixtures/crc8_helper.yaml Normal file
View File

@@ -0,0 +1,17 @@
esphome:
name: crc8-helper-test
host:
api:
logger:
level: INFO
external_components:
- source:
type: local
path: EXTERNAL_COMPONENT_PATH
components: [crc8_test_component]
crc8_test_component:

17
tests/integration/fixtures/external_components/crc8_test_component/__init__.py Normal file
View File

@@ -0,0 +1,17 @@
import esphome.codegen as cg
import esphome.config_validation as cv
from esphome.const import CONF_ID
crc8_test_component_ns = cg.esphome_ns.namespace("crc8_test_component")
CRC8TestComponent = crc8_test_component_ns.class_("CRC8TestComponent", cg.Component)
CONFIG_SCHEMA = cv.Schema(
{
cv.GenerateID(): cv.declare_id(CRC8TestComponent),
}
).extend(cv.COMPONENT_SCHEMA)
async def to_code(config):
var = cg.new_Pvariable(config[CONF_ID])
await cg.register_component(var, config)

170
tests/integration/fixtures/external_components/crc8_test_component/crc8_test_component.cpp Normal file
View File

@@ -0,0 +1,170 @@
#include "crc8_test_component.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
namespace esphome {
namespace crc8_test_component {
static const char *const TAG = "crc8_test";
void CRC8TestComponent::setup() {
ESP_LOGI(TAG, "CRC8 Helper Function Integration Test Starting");
// Run all test suites
test_crc8_dallas_maxim();
test_crc8_sensirion_style();
test_crc8_pec_style();
test_crc8_parameter_equivalence();
test_crc8_edge_cases();
test_component_compatibility();
ESP_LOGI(TAG, "CRC8 Integration Test Complete");
}
void CRC8TestComponent::test_crc8_dallas_maxim() {
ESP_LOGI(TAG, "Testing Dallas/Maxim CRC8 (default parameters)");
// Test vectors for Dallas/Maxim CRC8 (polynomial 0x8C, LSB-first, init 0x00)
const uint8_t test1[] = {0x01};
const uint8_t test2[] = {0xFF};
const uint8_t test3[] = {0x12, 0x34};
const uint8_t test4[] = {0xAA, 0xBB, 0xCC};
const uint8_t test5[] = {0x01, 0x02, 0x03, 0x04, 0x05};
bool all_passed = true;
all_passed &= verify_crc8("Dallas [0x01]", test1, sizeof(test1), 0x5E);
all_passed &= verify_crc8("Dallas [0xFF]", test2, sizeof(test2), 0x35);
all_passed &= verify_crc8("Dallas [0x12, 0x34]", test3, sizeof(test3), 0xA2);
all_passed &= verify_crc8("Dallas [0xAA, 0xBB, 0xCC]", test4, sizeof(test4), 0xD4);
all_passed &= verify_crc8("Dallas [0x01...0x05]", test5, sizeof(test5), 0x2A);
log_test_result("Dallas/Maxim CRC8", all_passed);
}
void CRC8TestComponent::test_crc8_sensirion_style() {
ESP_LOGI(TAG, "Testing Sensirion CRC8 (0x31 poly, MSB-first, init 0xFF)");
const uint8_t test1[] = {0x00};
const uint8_t test2[] = {0x01};
const uint8_t test3[] = {0xFF};
const uint8_t test4[] = {0x12, 0x34};
const uint8_t test5[] = {0xBE, 0xEF};
bool all_passed = true;
all_passed &= verify_crc8("Sensirion [0x00]", test1, sizeof(test1), 0xAC, 0xFF, 0x31, true);
all_passed &= verify_crc8("Sensirion [0x01]", test2, sizeof(test2), 0x9D, 0xFF, 0x31, true);
all_passed &= verify_crc8("Sensirion [0xFF]", test3, sizeof(test3), 0x00, 0xFF, 0x31, true);
all_passed &= verify_crc8("Sensirion [0x12, 0x34]", test4, sizeof(test4), 0x37, 0xFF, 0x31, true);
all_passed &= verify_crc8("Sensirion [0xBE, 0xEF]", test5, sizeof(test5), 0x92, 0xFF, 0x31, true);
log_test_result("Sensirion CRC8", all_passed);
}
void CRC8TestComponent::test_crc8_pec_style() {
ESP_LOGI(TAG, "Testing PEC CRC8 (0x07 poly, MSB-first, init 0x00)");
const uint8_t test1[] = {0x00};
const uint8_t test2[] = {0x01};
const uint8_t test3[] = {0xFF};
const uint8_t test4[] = {0x12, 0x34};
const uint8_t test5[] = {0xAA, 0xBB};
bool all_passed = true;
all_passed &= verify_crc8("PEC [0x00]", test1, sizeof(test1), 0x00, 0x00, 0x07, true);
all_passed &= verify_crc8("PEC [0x01]", test2, sizeof(test2), 0x07, 0x00, 0x07, true);
all_passed &= verify_crc8("PEC [0xFF]", test3, sizeof(test3), 0xF3, 0x00, 0x07, true);
all_passed &= verify_crc8("PEC [0x12, 0x34]", test4, sizeof(test4), 0xF1, 0x00, 0x07, true);
all_passed &= verify_crc8("PEC [0xAA, 0xBB]", test5, sizeof(test5), 0xB2, 0x00, 0x07, true);
log_test_result("PEC CRC8", all_passed);
}
void CRC8TestComponent::test_crc8_parameter_equivalence() {
ESP_LOGI(TAG, "Testing parameter equivalence");
const uint8_t test_data[] = {0x12, 0x34, 0x56, 0x78};
// Test that default parameters work as expected
uint8_t default_result = crc8(test_data, sizeof(test_data));
uint8_t explicit_result = crc8(test_data, sizeof(test_data), 0x00, 0x8C, false);
bool passed = (default_result == explicit_result);
if (!passed) {
ESP_LOGE(TAG, "Parameter equivalence FAILED: default=0x%02X, explicit=0x%02X", default_result, explicit_result);
}
log_test_result("Parameter equivalence", passed);
}
void CRC8TestComponent::test_crc8_edge_cases() {
ESP_LOGI(TAG, "Testing edge cases");
bool all_passed = true;
// Empty array test
const uint8_t empty[] = {};
uint8_t empty_result = crc8(empty, 0);
bool empty_passed = (empty_result == 0x00); // Should return init value
if (!empty_passed) {
ESP_LOGE(TAG, "Empty array test FAILED: expected 0x00, got 0x%02X", empty_result);
}
all_passed &= empty_passed;
// Single byte tests
const uint8_t single_zero[] = {0x00};
const uint8_t single_ff[] = {0xFF};
all_passed &= verify_crc8("Single [0x00]", single_zero, 1, 0x00);
all_passed &= verify_crc8("Single [0xFF]", single_ff, 1, 0x35);
log_test_result("Edge cases", all_passed);
}
void CRC8TestComponent::test_component_compatibility() {
ESP_LOGI(TAG, "Testing component compatibility");
// Test specific component use cases
bool all_passed = true;
// AGS10-style data (Sensirion CRC8)
const uint8_t ags10_data[] = {0x12, 0x34, 0x56};
uint8_t ags10_result = crc8(ags10_data, sizeof(ags10_data), 0xFF, 0x31, true);
ESP_LOGI(TAG, "AGS10-style CRC8: 0x%02X", ags10_result);
// LC709203F-style data (PEC CRC8)
const uint8_t lc_data[] = {0xAA, 0xBB};
uint8_t lc_result = crc8(lc_data, sizeof(lc_data), 0x00, 0x07, true);
ESP_LOGI(TAG, "LC709203F-style CRC8: 0x%02X", lc_result);
// DallasTemperature-style data (Dallas CRC8)
const uint8_t dallas_data[] = {0x28, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC};
uint8_t dallas_result = crc8(dallas_data, sizeof(dallas_data));
ESP_LOGI(TAG, "Dallas-style CRC8: 0x%02X", dallas_result);
all_passed = true; // These are just demonstration tests
log_test_result("Component compatibility", all_passed);
}
bool CRC8TestComponent::verify_crc8(const char *test_name, const uint8_t *data, uint8_t len, uint8_t expected,
uint8_t crc, uint8_t poly, bool msb_first) {
uint8_t result = esphome::crc8(data, len, crc, poly, msb_first);
bool passed = (result == expected);
if (passed) {
ESP_LOGI(TAG, "%s: PASS (0x%02X)", test_name, result);
} else {
ESP_LOGE(TAG, "%s: FAIL - expected 0x%02X, got 0x%02X", test_name, expected, result);
}
return passed;
}
void CRC8TestComponent::log_test_result(const char *test_name, bool passed) {
if (passed) {
ESP_LOGI(TAG, "%s: ALL TESTS PASSED", test_name);
} else {
ESP_LOGE(TAG, "%s: SOME TESTS FAILED", test_name);
}
}
} // namespace crc8_test_component
} // namespace esphome

29
tests/integration/fixtures/external_components/crc8_test_component/crc8_test_component.h Normal file
View File

@@ -0,0 +1,29 @@
#pragma once
#include "esphome/core/component.h"
#include "esphome/core/helpers.h"
#include "esphome/core/log.h"
namespace esphome {
namespace crc8_test_component {
class CRC8TestComponent : public Component {
public:
void setup() override;
private:
void test_crc8_dallas_maxim();
void test_crc8_sensirion_style();
void test_crc8_pec_style();
void test_crc8_parameter_equivalence();
void test_crc8_edge_cases();
void test_component_compatibility();
void test_old_vs_new_implementations();
void log_test_result(const char *test_name, bool passed);
bool verify_crc8(const char *test_name, const uint8_t *data, uint8_t len, uint8_t expected, uint8_t crc = 0x00,
uint8_t poly = 0x8C, bool msb_first = false);
};
} // namespace crc8_test_component
} // namespace esphome

100
tests/integration/test_crc8_helper.py Normal file
View File

@@ -0,0 +1,100 @@
"""Integration test for CRC8 helper function."""
from __future__ import annotations
import asyncio
from pathlib import Path
import pytest
from .types import APIClientConnectedFactory, RunCompiledFunction
@pytest.mark.asyncio
async def test_crc8_helper(
yaml_config: str,
run_compiled: RunCompiledFunction,
api_client_connected: APIClientConnectedFactory,
) -> None:
"""Test the CRC8 helper function through integration testing."""
# Get the path to the external components directory
external_components_path = str(
Path(__file__).parent / "fixtures" / "external_components"
)
# Replace the placeholder in the YAML config with the actual path
yaml_config = yaml_config.replace(
"EXTERNAL_COMPONENT_PATH", external_components_path
)
# Track test completion with asyncio.Event
test_complete = asyncio.Event()
# Track test results
test_results = {
"dallas_maxim": False,
"sensirion": False,
"pec": False,
"parameter_equivalence": False,
"edge_cases": False,
"component_compatibility": False,
"setup_started": False,
}
def on_log_line(line):
"""Process log lines to track test progress and results."""
# Track test start
if "CRC8 Helper Function Integration Test Starting" in line:
test_results["setup_started"] = True
# Track test completion
elif "CRC8 Integration Test Complete" in line:
test_complete.set()
# Track individual test results
elif "ALL TESTS PASSED" in line:
if "Dallas/Maxim CRC8" in line:
test_results["dallas_maxim"] = True
elif "Sensirion CRC8" in line:
test_results["sensirion"] = True
elif "PEC CRC8" in line:
test_results["pec"] = True
elif "Parameter equivalence" in line:
test_results["parameter_equivalence"] = True
elif "Edge cases" in line:
test_results["edge_cases"] = True
elif "Component compatibility" in line:
test_results["component_compatibility"] = True
# Log failures for debugging
elif "TEST FAILED:" in line or "SUBTEST FAILED:" in line:
print(f"CRC8 Test Failure: {line}")
# Compile and run the test
async with (
run_compiled(yaml_config, line_callback=on_log_line),
api_client_connected() as client,
):
# Verify device info
device_info = await client.device_info()
assert device_info is not None
assert device_info.name == "crc8-helper-test"
# Wait for tests to complete with timeout
try:
await asyncio.wait_for(test_complete.wait(), timeout=5.0)
except TimeoutError:
pytest.fail("CRC8 integration test timed out after 5 seconds")
# Verify all tests passed
assert test_results["setup_started"], "CRC8 test setup never started"
assert test_results["dallas_maxim"], "Dallas/Maxim CRC8 test failed"
assert test_results["sensirion"], "Sensirion CRC8 test failed"
assert test_results["pec"], "PEC CRC8 test failed"
assert test_results["parameter_equivalence"], (
"Parameter equivalence test failed"
)
assert test_results["edge_cases"], "Edge cases test failed"
assert test_results["component_compatibility"], (
"Component compatibility test failed"
)