Configuration Cover Groups

Cover Groups

A cover group is a single Adaptive Cover Pro entry that orchestrates a set of covers as one unit — a room, a facade, or a whole house. Instead of overriding each window by hand, you activate a scene, drag one cover control, or call one service, and the group fans the intent out to every member.

A group is not a geometric cover type. It has no window, no sun/geometry pipeline, and no position of its own — it is a meta-controller that drives other covers. It manages two kinds of member:

• ACP members — other Adaptive Cover Pro entries. The group delivers its intent through each member's pipeline, so weather safety, manual overrides, and the member's own automation still arbitrate.
• Generic HA covers — plain cover.* entities (Somfy RTS, KNX, MQTT, …) with no ACP geometry. The group commands them directly, giving them delta gating, min/max clamping, and inverse-state handling for free.

When to use a group vs. HA's Cover Group helper

Home Assistant's built-in Cover Group helper is a pass-through: it forwards open/close/set-position to several covers and reports an aggregate state. It has no scheduling, no scenes, no arbitration, and no awareness of any member's ACP pipeline.

An ACP cover group adds the orchestration on top:

	HA Cover Group helper	ACP Cover Group
Bulk open/close/position	✅	✅
Scenes resolved per cover type	❌	✅ (Open / Closed / Privacy)
Routes through each member's ACP pipeline	❌	✅ (weather & member safety still win)
Priority arbitration (scene / lock)	❌	✅
Gives a dumb cover ACP's gating/clamping	❌	✅ (adopt mode)
Per-member / per-scene opt-out	❌	✅
Live area-based membership	❌	✅

If you only want to move several covers together with a single control, the HA helper is fine. Reach for an ACP group when you want room-level scenes, want members to keep respecting their own sun/weather logic, or want to fold a dumb cover into ACP's command handling.

Creating a group

From the integration's Add menu (⋮ → Add Adaptive Cover Pro), choose Create cover group. One page collects everything you need:

1. Name — e.g. "Living Room" or "West Facade".
2. ACP members — a dropdown of your existing ACP cover entries (building profiles and other groups are excluded). Listed first.
3. Generic covers — an entity picker for plain cover.* entities that ACP does not manage. Listed below.
4. Area (optional) — pick a Home Assistant area to derive membership automatically (see Membership below).

You can leave either roster empty and add members later. An empty group is valid but commands nothing.

Membership

The roster lives on the group entry — members do not point back at the group. There are three ways to populate it, and they combine:

• ACP members are stored as config-entry references, not entities. This is deliberate: an ACP instance's proxy cover entity is opt-in, so a member might expose no cover. entity at all and would be invisible to an entity picker. Keying ACP members off their entry also means the group always orchestrates them through their pipeline, regardless of whether their proxy cover is on.
• Generic covers are stored as cover.* entity IDs and driven directly.
• Area membership — set a group's area and every ACP cover and generic cover in that area is folded in live. Membership re-resolves as entities move in and out of the area, so you don't re-edit the roster when your room changes.

Membership is sanitized on save: duplicates are dropped, the group's own entry is rejected, and a generic entity that actually belongs to a selected ACP member is ignored in favour of the ACP entry. Removing a member also prunes its per-scene opt-out entries so the arbitration screen never lists ghosts.

Edit the roster any time from the group's options under Members.

Scenes

A group ships three built-in scenes:

Scene	Meaning
All Open	Every member fully open
All Closed	Every member fully closed
Privacy	Block the view in while keeping the cover useful

A scene is a semantic intent, not an absolute position. Each member resolves it through its own cover-type policy (position_for_scene), so a venetian tilts its slats to block the view while an awning retracts and a roller drops — all from the same "Privacy" command. This is what makes a mixed-type group behave sensibly.

Activate a scene from the group's scene buttons, the scene select entity, or the group_activate_scene service. Selecting Auto (or passing "auto" to the service) releases the group's scene claim, so every member returns to its own automation.

Arbitration & priority

Scenes on ACP members ride the decision pipeline, so they arbitrate against everything else rather than blindly overwriting it:

• Group scene → priority 85. Above manual_override (80), so a room scene wins over a stale per-cover manual state — but below weather (90), so wind/rain safety on an outdoor member still overrides a group scene.
• Group lock → priority 100 (safety). Acts outside the tracking-time window and bypasses delta gates. A member's own safety slot is also 100, and the member wins ties — physical safety local to a cover always trumps a zone command.

Because scenes flow through the pipeline, each member's Decision Trace shows exactly why the group won or was outranked ("group scene won" vs. "outprioritized by weather"). The group also exposes a Who Won sensor summarizing, per member, whether the group or the member's own pipeline is currently driving it.

Per-member scene opt-out. In the group's Arbitration options you can exclude specific members from specific scenes (a single multi-select of member — scene pairs). An opted-out member ignores that scene but still responds to everything else. The group lock ignores opt-out — a lock is safety and reaches every member.

Generic (adopt-mode) covers have no pipeline, so the group applies the scene's resolved position to them directly through its own command service. Same intent, two delivery paths.

Synchronized movement

By default a group fans its command out to all members in one tick. Set a stagger delay (0–30 s, in the Arbitration options) to space member commands apart — useful for avoiding an inrush when a large facade all moves at once. True simultaneity is best-effort: orchestrate-mode members still run their own delta/time gates, so "in unison" means "commanded in the same cycle," not "arrive at the same instant."

The stagger only applies to commands the group itself sends. It lives in the group's fan-out path, so it spaces a scene activation, a group position call, or a lock release. It does not reach a member's own sun-tracking pipeline: each member calculates and fires on its own schedule, unaware of what any other entry is doing at that moment.

That distinction matters on one-way radio. If you set a stagger to stop Somfy RTS covers colliding, it will space your scenes and leave everyday automatic tracking exactly as unspaced as before, including between two different groups. Use a Command Queue for that: covers naming the same queue take turns whatever triggered them. The two are independent and work together.

Adopt mode for generic covers

Adopt mode is scoped to discrete targets — the resolved position of a scene and bulk position/open/close/stop commands. It does not attempt continuous sun-tracking of a dumb cover. If you want a generic cover to follow the sun with correct geometry, create a real ACP instance for it (it computes from that cover's own azimuth/height) rather than adopting it into a group.

The aggregate cover entity

A group can expose a single cover. entity that represents the whole group:

• Position reads the aggregate (average) of member positions.
• Set position / open / close / stop fan out to every member — ACP and generic — as a user command (member manual-override engagement and floor clamps apply, exactly like dragging a per-cover proxy).
• Tilt is exposed only when every member has a tilt axis; a mixed roster hides the tilt control.

This aggregate cover is enabled by default, so a new group is controllable as one cover straight out of the box — from a dashboard tile, the more-info dialog, or a voice assistant. If you'd rather keep it off a member-heavy group to reduce dashboard/voice clutter, disable it in the group's Entities options (Aggregate cover entity toggle).

Exposed entities

A group entry creates its own set of entities. Unique IDs follow the standard <entry_id>_<suffix> shape.

Platform	Entity	Enabled by
cover	Aggregate group cover	Aggregate cover entity toggle — on by default
sensor	Group position (aggregate)	Position sensor toggle (on)
sensor	Group state (open / closed / mixed)	State sensor toggle (on)
sensor	Group climate mode (rollup of members)	Climate sensor toggle (on)
sensor	Active scene	always
sensor	Who Won (per-member drive source)	Who-won sensor toggle (on)
select	Scene picker (Auto + the three scenes)	always
button	Activate scene (one per scene)	always
button	Clear member overrides	always
switch	Group lock (priority-100 intent)	always
switch	Group automation enable (bulk)	always

The scene select, scene buttons, and the two switches are the group's primary control surface and are always created. The aggregate cover and the four aggregate sensors have per-group toggles under Entities (all on by default).

Services

Six domain services target a group (by its entity, or by config_entry_id). With no target, each acts on all cover groups.

Service	What it does
group_activate_scene	Activate a scene (all_open / all_closed / privacy), or auto to release the claim
group_set_position	Move every member to a position (0–100%), with optional slat tilt
group_lock	Engage the priority-100 lock intent across the group
group_unlock	Release the lock
group_clear_overrides	Clear manual overrides on members (optionally a subset)
group_set_automation	Bulk enable/disable member automation

See Runtime Configuration Services for the full field reference.

Related pages

• Building Profile — share environmental sensors across covers (a member links a profile; a group shares no config, it orchestrates runtime intent only)
• Copy Settings to Other Covers — one-shot config copy between instances
• How It Decides — the pipeline that group scenes arbitrate within
• Entities · Proxy Cover Entity