diff --git a/esphome/components/cover/__init__.py b/esphome/components/cover/__init__.py index 41efd2ba7a..25e92e5c22 100644 --- a/esphome/components/cover/__init__.py +++ b/esphome/components/cover/__init__.py @@ -299,7 +299,21 @@ COVER_CONTROL_ACTION_SCHEMA = cv.Schema( ) async def cover_control_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) + + # Bit positions must match COVER_CONTROL_FIELDS in automation.h. + # CONF_STATE and CONF_POSITION both map to set_position (bit 1). + field_mask = 0 + if CONF_STOP in config: + field_mask |= 1 << 0 + if CONF_STATE in config or CONF_POSITION in config: + field_mask |= 1 << 1 + if CONF_TILT in config: + field_mask |= 1 << 2 + + control_template_arg = cg.TemplateArguments( + cg.RawExpression(f"static_cast({field_mask})"), *template_arg + ) + var = cg.new_Pvariable(action_id, control_template_arg, paren) if (stop := config.get(CONF_STOP)) is not None: template_ = await cg.templatable(stop, args, cg.bool_) cg.add(var.set_stop(template_)) diff --git a/esphome/components/cover/automation.h b/esphome/components/cover/automation.h index f121e5c2d6..e056a11ea5 100644 --- a/esphome/components/cover/automation.h +++ b/esphome/components/cover/automation.h @@ -46,49 +46,89 @@ template class ToggleAction : public Action { Cover *cover_; }; -template class ControlAction : public Action { +// Unique Empty per field so [[no_unique_address]] is guaranteed to coalesce. +namespace cover_action_detail { +template struct Empty {}; +} // namespace cover_action_detail + +// X-macro: (type, field_name, bit_index). Order/bits must match the +// inline field-mask computation in cover_control_to_code in __init__.py: +// stop=bit 0, position=bit 1 (also set by CONF_STATE), tilt=bit 2. +#define COVER_CONTROL_FIELDS(X) \ + X(bool, stop, 0) \ + X(float, position, 1) \ + X(float, tilt, 2) + +template class ControlAction : public Action { public: explicit ControlAction(Cover *cover) : cover_(cover) {} - TEMPLATABLE_VALUE(bool, stop) - TEMPLATABLE_VALUE(float, position) - TEMPLATABLE_VALUE(float, tilt) +#define COVER_FIELD_SETTER_(type, name, idx) \ + template void set_##name(V value) requires((Fields & (1 << (idx))) != 0) { this->name##_ = value; } +#define COVER_FIELD_APPLY_(type, name, idx) \ + if constexpr ((Fields & (1 << (idx))) != 0) \ + call.set_##name(this->name##_.value(x...)); +#define COVER_FIELD_DECL_(type, name, idx) \ + [[no_unique_address]] std::conditional_t<(Fields & (1 << (idx))) != 0, TemplatableFn, \ + cover_action_detail::Empty<(idx)>> \ + name##_{}; + + COVER_CONTROL_FIELDS(COVER_FIELD_SETTER_) void play(const Ts &...x) override { auto call = this->cover_->make_call(); - if (this->stop_.has_value()) - call.set_stop(this->stop_.value(x...)); - if (this->position_.has_value()) - call.set_position(this->position_.value(x...)); - if (this->tilt_.has_value()) - call.set_tilt(this->tilt_.value(x...)); + COVER_CONTROL_FIELDS(COVER_FIELD_APPLY_) call.perform(); } protected: Cover *cover_; + COVER_CONTROL_FIELDS(COVER_FIELD_DECL_) }; +#undef COVER_CONTROL_FIELDS -template class CoverPublishAction : public Action { +// X-macro: (type, field_name, bit_index). Order/bits must match the +// inline bitmask built in cover_template_publish_to_code in +// template/cover/__init__.py: position=bit 0 (also set by CONF_STATE), +// tilt=bit 1, current_operation=bit 2. +#define COVER_PUBLISH_FIELDS(X) \ + X(float, position, 0) \ + X(float, tilt, 1) \ + X(CoverOperation, current_operation, 2) + +template class CoverPublishAction : public Action { public: CoverPublishAction(Cover *cover) : cover_(cover) {} - TEMPLATABLE_VALUE(float, position) - TEMPLATABLE_VALUE(float, tilt) - TEMPLATABLE_VALUE(CoverOperation, current_operation) + +#define COVER_PUBLISH_SETTER_(type, name, idx) \ + template void set_##name(V value) requires((Fields & (1 << (idx))) != 0) { this->name##_ = value; } +#define COVER_PUBLISH_APPLY_(type, name, idx) \ + if constexpr ((Fields & (1 << (idx))) != 0) \ + this->cover_->name = this->name##_.value(x...); +#define COVER_PUBLISH_DECL_(type, name, idx) \ + [[no_unique_address]] std::conditional_t<(Fields & (1 << (idx))) != 0, TemplatableFn, \ + cover_action_detail::Empty<(idx) + 8>> \ + name##_{}; + + COVER_PUBLISH_FIELDS(COVER_PUBLISH_SETTER_) void play(const Ts &...x) override { - if (this->position_.has_value()) - this->cover_->position = this->position_.value(x...); - if (this->tilt_.has_value()) - this->cover_->tilt = this->tilt_.value(x...); - if (this->current_operation_.has_value()) - this->cover_->current_operation = this->current_operation_.value(x...); + COVER_PUBLISH_FIELDS(COVER_PUBLISH_APPLY_) this->cover_->publish_state(); } protected: Cover *cover_; + COVER_PUBLISH_FIELDS(COVER_PUBLISH_DECL_) + +#undef COVER_PUBLISH_DECL_ +#undef COVER_PUBLISH_APPLY_ +#undef COVER_PUBLISH_SETTER_ +#undef COVER_FIELD_DECL_ +#undef COVER_FIELD_APPLY_ +#undef COVER_FIELD_SETTER_ }; +#undef COVER_PUBLISH_FIELDS template class CoverPositionCondition : public Condition { public: diff --git a/esphome/components/template/cover/__init__.py b/esphome/components/template/cover/__init__.py index a30c0af313..7dd3cddf47 100644 --- a/esphome/components/template/cover/__init__.py +++ b/esphome/components/template/cover/__init__.py @@ -128,7 +128,21 @@ async def to_code(config): ) async def cover_template_publish_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) + + # Bit positions must match COVER_PUBLISH_FIELDS in cover/automation.h. + # CONF_STATE and CONF_POSITION both map to set_position (bit 0). + field_mask = 0 + if CONF_STATE in config or CONF_POSITION in config: + field_mask |= 1 << 0 + if CONF_TILT in config: + field_mask |= 1 << 1 + if CONF_CURRENT_OPERATION in config: + field_mask |= 1 << 2 + + publish_template_arg = cg.TemplateArguments( + cg.RawExpression(f"static_cast({field_mask})"), *template_arg + ) + var = cg.new_Pvariable(action_id, publish_template_arg, paren) if CONF_STATE in config: template_ = await cg.templatable(config[CONF_STATE], args, cg.float_) cg.add(var.set_position(template_)) diff --git a/tests/integration/fixtures/cover_control_action.yaml b/tests/integration/fixtures/cover_control_action.yaml new file mode 100644 index 0000000000..f9eaa2ceee --- /dev/null +++ b/tests/integration/fixtures/cover_control_action.yaml @@ -0,0 +1,111 @@ +esphome: + name: cover-control-action-test +host: +api: +logger: + level: DEBUG + +globals: + - id: test_position + type: float + initial_value: "0.42" + +cover: + - platform: template + name: "Test Cover" + id: test_cover + has_position: true + optimistic: true + assumed_state: true + open_action: + - cover.template.publish: + id: test_cover + position: 1.0 + close_action: + - cover.template.publish: + id: test_cover + position: 0.0 + stop_action: + - cover.template.publish: + id: test_cover + current_operation: IDLE + tilt_action: + - lambda: |- + // Manually set tilt and publish + id(test_cover).tilt = tilt; + id(test_cover).publish_state(); + +button: + # Test 1: cover.control with position only (mask 0b010 = 2) + - platform: template + id: btn_position + name: "Set Position" + on_press: + - cover.control: + id: test_cover + position: 50% + + # Test 2: cover.control with tilt only (mask 0b100 = 4) + - platform: template + id: btn_tilt + name: "Set Tilt" + on_press: + - cover.control: + id: test_cover + tilt: 75% + + # Test 3: cover.control with position + tilt (mask 0b110 = 6) + - platform: template + id: btn_pos_tilt + name: "Set Pos Tilt" + on_press: + - cover.control: + id: test_cover + position: 25% + tilt: 30% + + # Test 4: cover.control with state alias (sets position bit via CONF_STATE) + - platform: template + id: btn_open_state + name: "Open State" + on_press: + - cover.control: + id: test_cover + state: OPEN + + # Test 5: cover.control with lambda position (exercises lambda path) + - platform: template + id: btn_lambda_position + name: "Lambda Position" + on_press: + - cover.control: + id: test_cover + position: !lambda "return id(test_position);" + + # Test 6: cover.template.publish position only (mask 0b001) + - platform: template + id: btn_publish_pos + name: "Publish Pos" + on_press: + - cover.template.publish: + id: test_cover + position: 0.6 + + # Test 7: cover.template.publish current_operation only (mask 0b100) + - platform: template + id: btn_publish_op + name: "Publish Op" + on_press: + - cover.template.publish: + id: test_cover + current_operation: OPENING + + # Test 8: cover.control with stop only (mask 0b001 = 1) — runs after + # Publish Op so we can verify current_operation transitions OPENING -> IDLE + - platform: template + id: btn_stop + name: "Stop Cover" + on_press: + - cover.control: + id: test_cover + stop: true diff --git a/tests/integration/test_cover_control_action.py b/tests/integration/test_cover_control_action.py new file mode 100644 index 0000000000..29ece37ce5 --- /dev/null +++ b/tests/integration/test_cover_control_action.py @@ -0,0 +1,92 @@ +"""Integration test for cover ControlAction and CoverPublishAction. + +Tests that cover.control and cover.template.publish automation actions +work correctly with the per-instance bitmask field storage. Exercises +multiple field combinations to cover the bitmask variants. +""" + +from __future__ import annotations + +import asyncio + +from aioesphomeapi import ButtonInfo, CoverInfo, CoverState, EntityState +import pytest + +from .state_utils import InitialStateHelper, require_entity +from .types import APIClientConnectedFactory, RunCompiledFunction + + +@pytest.mark.asyncio +async def test_cover_control_action( + yaml_config: str, + run_compiled: RunCompiledFunction, + api_client_connected: APIClientConnectedFactory, +) -> None: + """Test cover ControlAction/CoverPublishAction with constants and lambdas.""" + loop = asyncio.get_running_loop() + async with run_compiled(yaml_config), api_client_connected() as client: + cover_state_future: asyncio.Future[CoverState] | None = None + + def on_state(state: EntityState) -> None: + if ( + isinstance(state, CoverState) + and cover_state_future is not None + and not cover_state_future.done() + ): + cover_state_future.set_result(state) + + async def wait_for_cover_state(timeout: float = 5.0) -> CoverState: + nonlocal cover_state_future + cover_state_future = loop.create_future() + try: + return await asyncio.wait_for(cover_state_future, timeout) + finally: + cover_state_future = None + + entities, _ = await client.list_entities_services() + initial_state_helper = InitialStateHelper(entities) + client.subscribe_states(initial_state_helper.on_state_wrapper(on_state)) + await initial_state_helper.wait_for_initial_states() + + require_entity(entities, "test_cover", CoverInfo) + + async def press_and_wait(name: str) -> CoverState: + btn = require_entity(entities, name.lower().replace(" ", "_"), ButtonInfo) + client.button_command(btn.key) + return await wait_for_cover_state() + + # Test 1: position only (mask 2) + state = await press_and_wait("Set Position") + assert state.position == pytest.approx(0.5, abs=0.01) + + # Test 2: tilt only (mask 4) + state = await press_and_wait("Set Tilt") + assert state.tilt == pytest.approx(0.75, abs=0.01) + + # Test 3: position + tilt (mask 6) + state = await press_and_wait("Set Pos Tilt") + assert state.position == pytest.approx(0.25, abs=0.01) + assert state.tilt == pytest.approx(0.30, abs=0.01) + + # Test 4: state: OPEN (CONF_STATE alias for position 1.0) + state = await press_and_wait("Open State") + assert state.position == pytest.approx(1.0, abs=0.01) + + # Test 5: lambda position (test_position global = 0.42) + state = await press_and_wait("Lambda Position") + assert state.position == pytest.approx(0.42, abs=0.01) + + # Test 6: cover.template.publish position only + state = await press_and_wait("Publish Pos") + assert state.position == pytest.approx(0.6, abs=0.01) + + # Test 7: cover.template.publish current_operation only + state = await press_and_wait("Publish Op") + # CoverOperation.OPENING == 1 + assert state.current_operation == 1 + + # Test 8: cover.control stop only (mask 1) + # The template cover's stop_action publishes current_operation: IDLE + state = await press_and_wait("Stop Cover") + # CoverOperation.IDLE == 0 + assert state.current_operation == 0