Venetian blinds, Matter over Thread, and the question: which actuator actually controls slats precisely?
Background
I’ve been automating my home with Home Assistant for some time, gradually equipping all my blinds with Shelly 2PM Gen4 actuators. The basic functions – up, down, stop – work flawlessly. But with venetian blinds, a persistent problem emerges: slat tilt cannot be set reliably and precisely. The Shelly estimates tilt position using timing values, which regularly leads to inaccurate results due to drift and mechanical tolerances. In my case, I even had to build in a fixed offset of +10: if you want slats at 30% open, you have to send the Shelly a value of 40.
When I came across the WAGO Home Blind Control (model 2757-1106) – a Matter-over-Thread actuator specifically designed for blinds and shutters – I wanted to try it. At around CHF 60–80 it’s more expensive than a Shelly 2PM Gen4, but the promise of clean slat control was compelling. I ordered one WAGO, installed it on a blind that hadn’t yet been automated, and documented the experience over several weeks.
Device Overview
| Shelly 2PM Gen4 | WAGO 2757-1106 | |
|---|---|---|
| Protocol | Wi-Fi (+ Matter) | Matter over Thread |
| Form factor | Compact, flush-mount | Slightly larger (46×46×22mm) |
| Price (approx.) | CHF 30–40 | CHF 60–80 |
| Tilt control | Timing-based (imprecise) | Matter Window Covering Cluster |
| Local button inputs | I1/I2 (terminals) | Inputs 1/2 (terminals) |
| Smart home integration | Wi-Fi native, Matter optional | Matter native |
| HomeKit | Via HA Bridge | Via HA Bridge or direct |
Installation: WAGO on a Feller Zeptrion Flush-Mount Box
My blinds were previously controlled by a Feller Zeptrion Motor 1K (art. 2304) – an electronic blind insert with its own bus system. The Zeptrion terminals are:
- N – Neutral wire
- L – Phase
- ▲ / ▼ – Motor outputs up/down
- Z / K – Zeptrion bus (central control / secondary switch)
In my installation, Z and K were unused – no bus system, no secondary switches. Wiring the WAGO was therefore straightforward:
Zeptrion N → WAGO N
Zeptrion L → WAGO L
Zeptrion ▲ → WAGO M↑
Zeptrion ▼ → WAGO M↓
The Z/K wires were isolated and capped – they play no role in the new setup, as central control is now handled through Home Assistant automations.
Note: If your Z or K terminals are in use (secondary switches, central buttons), check whether you still need them to function. The WAGO does not understand the Zeptrion bus protocol – central control must be rebuilt as HA automations.
Installation Experience
The WAGO is marginally larger than a Shelly 2PM Gen4 but fits into a standard flush-mount box (tight in my case, but manageable). The WAGO push-in terminals (orange levers visible in the photo) are high quality and make wiring pleasantly straightforward – no screws, no crimping.
Commissioning: Matter over Thread
This is where the biggest difference from the Shelly lies. The WAGO communicates exclusively via Matter over Thread– no Wi-Fi, no MQTT, no proprietary protocol.
Thread Border Router: A Prerequisite
Thread requires at least one Thread Border Router. I run 7 HomePods and 3 Apple TVs, which provides excellent Thread infrastructure. Anyone running HA without the Apple ecosystem needs their own border router, such as the Home Assistant Connect ZBT-2 (more on this later).
Pairing: Directly into Home Assistant
Importantly, I paired the WAGO directly in Home Assistant (Settings → Devices & Services → Matter → Add device), not via the Apple Home app. Pairing it in Apple Home first and then adding it to HA creates a dual-fabric problem: both controllers compete for the same actuator, causing regular dropouts.
Rule for WAGO (and all Matter devices): always pair in your primary controller first – in my case, Home Assistant. Apple Home then sees the WAGO via the HomeKit Bridge.
Home Assistant Integration
After pairing, the WAGO appears as a native cover entity in HA:
cover.<room>_blinds
The entity supports out of the box:
cover.open_cover/cover.close_covercover.stop_covercover.set_cover_position(height 0–100%)cover.set_cover_tilt_position(slat tilt 0–100%)
No offset, no workaround, no calibration run. The WAGO sets tilt position directly and precisely.
Dashboard: Tilt Presets
I created a generic script reusable for all WAGO blinds:
yaml
alias: Tilt Preset Generic
fields:
entity_id:
name: Cover entity
required: true
selector:
entity:
domain: cover
tilt:
name: Tilt value
required: true
selector:
number:
min: 0
max: 100
sequence:
- action: cover.set_cover_tilt_position
target:
entity_id: "{{ entity_id }}"
data:
tilt_position: "{{ tilt }}"
In the dashboard I combine the native tilt slider of the Cover Tile Card with 5 quick-access buttons (0%, 30%, 35%, 40%, 100%) – the buttons call the generic script with the respective entity and target value.
Apple Home Integration via HomeKit Bridge
Since HA acts as the primary Matter controller, the WAGO is exposed to Apple Home via the HomeKit Bridge (HA’s homekit: integration). For tilt presets, HomeKit requires static scenes (not scripts, as scripts appear as toggle switches in the Home app):
yaml
# scenes.yaml
- id: "wago_<room>_tilt_35"
name: WAGO <Room> Blinds Tilt 35%
entities:
cover.<room>_blinds:
current_position: 100
current_tilt_position: 35
device_class: shutter
supported_features: 255
state: open
In configuration.yaml, scenes are given short names for the Home app:
yaml
entity_config:
scene.wago_<room>_blinds_tilt_35:
name: "Tilt 35%"
A native tilt slider is unfortunately not available in the Apple Home app – tilt control there runs exclusively through the 5 preset scenes.
Manual Control: Shelly BLU RC Button 4 ZB
As a wireless wall switch I use the Shelly BLU RC Button 4 ZB – a 4-button Zigbee switch integrated into HA via Zigbee2MQTT. Button assignment for the test blind:
| Button | Press | Action |
|---|---|---|
| 1 | 1× | Open blind fully |
| 2 | 1× | Stop (hold current position + slat angle) |
| 3 | 1× | Slats to 30% |
| 3 | 2× | Slats to 35% |
| 3 | 3× | Slats to 40% |
| 4 | 1× | Close blind fully |
The automation listens to MQTT events (zigbee2mqtt/<Room> Shutter Button) and controls the WAGO cover entity directly via HA service calls – with no physical wiring between switch and actuator. This is a key architectural advantage over hardwired solutions: button assignments can be changed in HA at any time, without opening a wall.
The Tilt Problem: WAGO vs. Shelly Head-to-Head
This was my primary motivation for the test.
Shelly 2PM Gen4
The Shelly estimates slat position through timing. It knows: “If I run the motor for X milliseconds in one direction, the slats will be at approximately Y%.” This works acceptably on new, well-adjusted motors – but:
- Mechanical drift (aging, temperature) makes the estimate less accurate over time
- Each blind can have a different offset (mine: +10)
- After a power cut or reset, recalibration is needed
- “Tilt 30%” and an actual 30° slat opening can diverge significantly
WAGO 2757-1106
The WAGO implements the Matter Window Covering Cluster with the native GoToTiltPercentage command. Slat control is:
- Reproducible: 35% is always 35%, with no offset corrections
- Direct: No detour through timing estimates
- Stable: No drift after a power cut
- Calibration-free: No per-device manual adjustment needed
In practice: I can drive the slats to exactly the same position every single time. With the Shelly, regular readjustment was necessary.
Thread Stability: The Underestimated Problem
This was my biggest learning curve. After commissioning, the WAGO had regular offline dropouts – sometimes 10–30 minutes at a time, with no obvious cause.
The Root Cause
HA does not communicate with Thread devices directly, but via a Thread Border Router as intermediary. In my case: Apple HomePods. The communication chain was:
HA Matter Server → (IPv6/LAN) → Apple HomePod → (Thread) → WAGO
When a HomePod restarted or the Thread mesh switched paths, HA lost contact – even though Apple Home continued to reach the WAGO without issue. Apple’s native Thread stack is significantly more stable than HA’s dependency on a third-party border router.
The Solution: Home Assistant Connect ZBT-2
The Home Assistant Connect ZBT-2 (formerly SkyConnect) is a USB stick with its own Thread/Zigbee radio chip. Plugged into the Raspberry Pi (HA host), it sets itself up as an Open Thread Border Router (OTBR) and joins the existing Thread mesh.
HA Matter Server → (internal, direct) → ZBT-2 → (Thread) → WAGO
After setup: no more offline dropouts. HA now has a direct Thread connection, independent of Apple devices. The Thread mesh continues to dynamically choose the best path (ZBT-2 or HomePod), but HA’s Matter fabric connection remains stable.
Important for anyone running WAGO or other Matter-over-Thread devices with HA: your own Thread Border Router (e.g. ZBT-2, approx. CHF 35) is not optional – it is a prerequisite for stable operation.
Architecture Overview: The Final Setup
Apple Home App
│
│ (HomeKit Bridge)
▼
Home Assistant ←──── ZBT-2 ←──── Thread Mesh ←──── WAGO 2757-1106
│ │
│ (Zigbee2MQTT / MQTT) └──── HomePods / Apple TVs
▼ (as border routers)
Shelly BLU RC Button 4 ZB
(wireless wall switch, Zigbee)
Conclusion and Recommendation
WAGO 2757-1106 – Who Is It For?
Recommended if:
- Venetian blinds need precise slat control
- A Matter-native ecosystem is preferred
- Multiple blinds will eventually run unified via HA/Matter
- A Thread Border Router (ZBT-2) is already available or planned
Less suitable if:
- Simple roller blinds with no slat control
- No Thread infrastructure available and none planned
- Cost-sensitive project (Shelly is significantly cheaper)
Shelly 2PM Gen4 – Remains Competitive
The Shelly remains my choice for simple blinds without slat control – affordable, reliable, and the Wi-Fi architecture is less complex (no Thread border router needed). For venetian blinds with precision requirements, however, the WAGO is the clearly better choice.
My Next Step
I plan to gradually migrate all venetian blinds in the house to WAGO. The architecture (generic HA script, scenes for HomeKit, Shelly BLU RC Button as wall switch) is now cleanly defined and easy to scale – for each new blind, I only need to swap the cover entity ID.
Written July 2026. Setup: Home Assistant on Raspberry Pi, Zigbee2MQTT, Matter Server 9.0.4, WAGO firmware 2.0.0, ZBT-2 with OpenThread RCP 2.7.2.0.