Posts on Smart Home? Sure — But Secure!

I Made My Range Hood Smart – For the Second Time

Thu, 22 Oct 2026 00:00:00 +0000

Advertising: The video for this article is sponsored by PCBWay – PCBWay paid me and covered the cost of the boards. Links to PCBWay are affiliate links. Content and opinions are my own.

I have now made my range hood smart for the second time. The first time was in 2017, with a perfboard that ran for eight years. Still, I replaced it – not because it broke, but because it turned out it never really worked properly. And because my eyes and hands just don’t cooperate with fine soldering anymore.

The result is my very first own circuit board: designed in KiCad, coached by an AI, manufactured by PCBWay.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The problem: the quietest range hood in the world

Our hood is quiet – on the lowest setting you simply can’t hear it. You cook, you eat, you go to the living room, and the hood keeps running, sometimes all night. We only noticed because the kitchen was cold in the morning: whatever the hood blows outside has to come back in through windows, doors and every gap. So the thing had to become smart enough to switch itself off.

2017: The hack in the cable

My hood, a Gutmann Sombra, has no interface at all – no Wi-Fi, no bus. And Gutmann is insolvent, so no spare parts. But between the control panel and the hood electronics runs a cable with an RJ45 plug. The panel itself contains no logic, just seven buttons and some LEDs. The hood scans them as a matrix: four lines are pulled high one after another for one millisecond each, and the LEDs only flash briefly – fast enough to look steady.

I figured this out in 2017 with an oscilloscope and without any documentation. The result: an ESP8266 that reads along in the hood’s rhythm and “presses” buttons at the right moment, while the original panel keeps working. Details are in my 2017 blog post (German).

Eight years – with a safety net

The circuit moved onto a perfboard in a small case inside the hood. Home Assistant switched the hood off after one hour and reminded me to clean the grease filter whenever the dishwasher started. But a watchdog automation cut the hood’s power via a Shelly about every two months, and a night-time power cut kept it from switching on by itself. Workaround after workaround.

My first KiCad project – with an AI coach

This year the hood went offline more and more often. A new perfboard attempt ended in solder bridges, so I designed a real PCB in KiCad – my first ever. Claude (Anthropic) acted as a coach: I drew and routed everything myself, Claude reviewed schematic and layout. It caught 5 V and 3.3 V shorted on the same net (the ESP8266 tolerates at most 3.6 V), explained decoupling capacitors, and helped find a wire that was half a grid point (1.27 mm) off. It was wrong sometimes too – an advisor, not an autopilot.

The mystery of the old board

The hood supplies only about 4.9 V. My old regulator wanted more, so whenever the ESP transmitted, the voltage dropped, the regulator lost control and the ESP rebooted – sometimes into a boot loop. Wi-Fi was never the problem. The fix is a TPS63802 buck-boost converter plus large buffer capacitors (1000 µF and 470 µF). All six mistakes of the old board are documented on GitHub.

Ordering, assembling, fixing

I ordered the boards from PCBWay: enter size, layers and quantity first, get a price, then upload the Gerber files in the cart; an engineer reviews them before you pay. Almost all parts are through-hole, only the ESP module is SMD – so I could solder them myself and retrofit later. That paid off: swapped matrix lines were fixed in firmware, and “ghost” button presses (floating inputs on the driver chip) were fixed with two pull-down resistors and two diodes soldered to the bottom. Revision 0.3 in the repository includes this fix but was never manufactured.

Result

The board sits where the old one did, and Home Assistant discovers the hood automatically via MQTT Discovery. I removed the night-time power cut on purpose – and since the rebuild at the end of September 2026, the watchdog has not triggered once.

I have 4 boards left. If you own a Gutmann hood or one built the same way, leave a comment under the video.

Shelly Gen1 to Gen4: What Really Changed – and Why My 2.5s Are Going

Thu, 08 Oct 2026 00:00:00 +0000

More than 50,000 people have watched the video in which I repair a dead Shelly 2.5 for 30 cents: Repairing dead Shellys – the 30-cent fix. I’ve done this repair at home easily more than ten times. And now the last 2.5s are going anyway – replaced by the Shelly 2PM Gen4.

In this article: why repairing no longer pays off for me, what really changed across four Shelly generations – from the chip to the screws – and how the swap went, including a mishap that can happen to you too.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Why repairing no longer pays off for me

What I couldn’t know when I made the repair video: every 2.5 I repaired failed again after a while. I didn’t track it precisely, roughly two to three years. And that’s despite fitting a high-quality Panasonic capacitor. The community now recommends replacing all three capacitors in the device right away. Whether that’s enough, I can’t say.

Then there’s the effort. One round means: breaker off, switch cover off, module out, case open, solder, reassemble, reinstall and set up again. Including removal and installation, that’s about 45 minutes per device for me.

But the real point is a different one: the 2.5 is technically outdated – it’s now more than seven years old. So my advice: if your 2.5 fails today, that’s the moment to think about switching. After two years, the repair was certainly the right call back then. At the second or third failure of the same device, the math looks different.

If repairing is still an option for you: everything I’ve learned since the video is in the update to the repair article.

Old and new: the Shelly 2.5 on the left, the 2PM Gen4 on the right.

Four generations at a glance

From left: Shelly 2.5 (Gen1), Plus 2PM (Gen2) and 2PM Gen4. I skipped the third generation.

	2.5 (Gen1)	Plus 2PM (Gen2)	2PM Gen3	2PM Gen4
Chip	ESP8266	ESP32	ESP-Shelly-C38F	ESP-Shelly-C68F
Flash	2 MB	4 MB	8 MB	8 MB
Wi-Fi	2.4 GHz	2.4 GHz	2.4 GHz	Wi-Fi 6, 2.4 GHz
Bluetooth	–	4.2	4.2	5.0
Matter	–	–	on some models	built in
Zigbee	–	–	–	built in (switchable)
Wires up to	1.5 mm²	1.5 mm²	4 mm²	4 mm²
Printed wiring diagram	no	yes	yes	yes
Size (H × W × D)	36 × 39 × 17 mm	37 × 42 × 16 mm	37 × 42 × 16 mm	37 × 42 × 16 mm

Sources: datasheets in the Shelly Knowledge Base, my own devices.

Gen1: the brilliant idea

The first generation arrived in 2018 with the Shelly 1 and, shortly after, the 2.5. The idea was brilliant: a small relay behind the switch, straight on Wi-Fi, with its own web interface – no hub or bridge at all. Under the hood an ESP8266 with just 2 MB of storage, outside slotted screws and terminals for wires up to 1.5 mm². A solid start, with plenty of room for improvement.

Gen2 (Plus): Bluetooth, scripts, slats

The Plus devices – for me the Plus 2PM – brought an ESP32 and with it Bluetooth. Setup via the app gets easier, and the Shelly can receive Bluetooth sensors and pass them on, for example to Home Assistant. Scripts run directly on the device, and cloud connection and local MQTT suddenly work at the same time.

Particularly important for me: percentage-accurate slat control for venetian blinds. How to set it up and use it in automations: Tilt Venetian Blind Slats to the Percent with Shelly and Home Assistant.

Scripts directly on the Shelly – here the Bluetooth script that Home Assistant installs itself.

On the outside, the case is one millimetre flatter (a little wider and taller in return), and there’s finally a small printed wiring diagram. Just right when you’re kneeling in front of the wall and the manual is, of course, in the kitchen.

Gen3: skipped

I skipped the third generation. Same case, a new chip with twice the storage, a KNX connection via a gateway, and Matter on some models. Most importantly, the terminals now take wires up to 4 mm² – thick wires and ferrules finally go in without fiddling.

Gen4: Matter and Zigbee built in

The 2PM Gen4 keeps the same case, but a lot changes inside: Wi-Fi 6, still on 2.4 GHz (so no new Wi-Fi needed), Bluetooth 5.0, twice the RAM of the Gen3 according to the datasheet, and Matter and Zigbee built in. The Gen4 ships in Matter mode; pressing the button five times switches it to the Zigbee profile.

And on the outside there are finally combination screws for slotted and Phillips. Don’t laugh – but I love it: tightening with a Phillips screwdriver without constantly slipping out of the slot.

Combination screw on the Gen4: fits slotted and Phillips screwdrivers.

The terminals: different in every generation

My personal highlight: with every generation, the terminal order changes again.

German labels: Neutralleiter = neutral, Phase = live, Ausgänge = motor outputs, Tastereingänge = switch inputs.

The neutral sits on the far right on the 2.5, on the far left on the Plus 2PM, and on the far right again on the Gen4.
The switch inputs were split across both sides on the 2.5 (SW2 left, SW1 right). Since the second generation they sit next to each other and are called S1 and S2.
The two L terminals are next to each other on all three devices.

So please: wire by the label, not by habit – especially when you replace a 2.5 one to one.

The swap

The mishap: a broken wire

On the very first swap, something happened that can happen to you too: the wire was already worn from all the removing and reinstalling, and it broke off. The small piece of bare wire was, of course, stuck in the front of the terminal. In the end I only got it out with a lot of fiddling and very pointy tweezers.

The broken-off piece of wire is stuck in the front of the terminal.

My tip: if a box has been opened a few times already, take a close look at the wires and trim them cleanly once before this happens to you.

Calibrate and flip the direction

Next, the usual Shelly calibration run. And bam: the shutter went down on “up”. Direction swapped during wiring – but you don’t have to rewire. In the web interface, the cover settings have a “Reverse directions” checkbox for exactly this.

Swap the direction in software instead of rewiring.

The Matter QR code – twice

A detail I really like: the Gen4 comes with the Matter QR code twice. Once stuck firmly on the device – which of course is no longer accessible once it’s installed. And once as a loose sticker. I stuck that one on the inside of the switch cover. If I ever need to pair the device again, I can get to the code without opening the box.

On the device and loose in the switch cover. I’ve blurred the QR code and pairing number.

As long as the Shelly is online, the QR code is also available virtually in the web interface.

Setup: Matter instead of an open hotspot

The biggest difference during setup isn’t the hardware, it’s Matter. You set up the old devices via an open, unencrypted Wi-Fi hotspot – and without the Shelly app that’s always a bit fiddly. I paired the Gen4 straight from the Home Assistant app on my iPhone: scan the QR code, done, the device is on Wi-Fi. Matter transfers the credentials encrypted. It hardly gets safer or more convenient.

But: at first, no shutter showed up in Home Assistant. Why, and how I fixed it myself in Home Assistant, is in Shelly via Matter was broken – so I fixed it in Home Assistant. In short: use Home Assistant 2026.9.3 or later and calibrate the Shelly.

Version number pitfall: via Matter, Home Assistant shows firmware version 1.3.0. That has nothing to do with the Shelly firmware version in the web interface – mine showed 1.7, and 2.0 after the update. Two different numbers, so don’t be surprised.

Three tips for the swap

Passive Bluetooth: if, like me, you receive Bluetooth sensors via your Shellys, enable passive Bluetooth mode on the Gen4 in Home Assistant again (Shelly integration → Configure → Bluetooth scanner mode “Passive”). Then everything keeps working as before.

Venetian blinds: you can tilt the slats to the percent – by the way, the second generation can already do that, my old 2.5 couldn’t. Details in the venetian blind article.

Same entity ID: give the new device the same entity ID in Home Assistant as the old one. Then your automations and dashboards keep running without a single change – for me, among others, the shading from Home Assistant A-Z: J for Jalousien.

The basics of shutter control with Shelly – switches, terminals, device profile – are in Making blinds smart with Shelly.

Conclusion

The 30-cent fix wasn’t a bad recommendation. It brings a dead Shelly back to life for very little money – and who wants to throw away a device after two or three years? Back then, the Plus devices also weren’t attractive enough for me to switch right away.

After two or more repair cycles, though, it’s a different story. The Gen4 brings a lot of new features, is easier to wire and safer to set up. For me, it’s now a well-rounded package.

Which Shelly generation runs in your home? Are you happy with it, or do you miss one of the new features? Let me know in the comments. The Gen4 can do a lot more than fits into one article – Matter, Zigbee or the Shelly integration is something I’ll look at more closely.

Products from this article

Shelly 2PM Gen4 – directly from Shelly (paid link): https://upf.ai/l24blt88 · discount code SMARTHOMEABERSICHER-10OFF for 10% off
Shelly 2PM Gen4 on Amazon (paid link): https://link.amazon/B05GmP3lz · the discount code doesn’t apply there

Shelly via Matter was broken – so I fixed it in Home Assistant

Thu, 01 Oct 2026 00:00:00 +0000

Shelly sent me a whole box of the new Shelly 2PM Gen4 – my first Shellys with Matter over Wi-Fi. So I tried it right away. And even though smart home is all I’ve been doing for years: I failed, right on the first device. The bug had been known for over a year. Since Home Assistant 2026.9.3 it’s gone – because I ended up fixing it myself.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The symptom: device yes, shutter no

Pairing via Matter is pleasant: scan the QR code in the Home Assistant app, done. No open Wi-Fi hotspot, no Wi-Fi password sent in plain text, no Shelly app – Matter transfers the credentials to the device encrypted.

But: Home Assistant created no cover entity. The device was there, firmware version and IP address too – but no up, no down, no stop.

Device detected, firmware shown – but no shutter controls.

I wasn’t the first: the problem has been documented since August 2025 in home-assistant/core#149876, with more than 30 comments.

On the next install I swapped two devices: one for a regular roller shutter, one for external venetian blinds. For the blinds I enabled Slat Control in the Shelly web interface – and suddenly the cover entity appeared, with sliders for position and tilt.

This is what venetian blinds look like in Home Assistant: one slider for position, one for tilt.

The regular shutter: still nothing. Enabled Slat Control there as a test – entity appeared, but with a second slider that does nothing.

The cause

With Matter, a device reports what it can do and delivers the matching values:

	What the Shelly reports (no slats)
FeatureMap	lift yes, tilt no – correct
AttributeList	still contains the tilt value `CurrentPositionTiltPercent100ths`
Value	`null` – i.e. “empty”, not the number 0

Excerpt from the Matter server: cluster 258 is window covering. Attribute 15 (tilt) is null, attribute 65532 (FeatureMap) is 5 – lift yes, tilt no.

Home Assistant used to treat the tilt value as required during discovery. Required value empty → the device matches no schema → no entity at all, not even a simple one for a shutter without slats.

Four “drawers” for covers – because of the empty tilt value, the Shelly fits none of them.

Whose fault is it?

You could argue that without slats, the Shelly shouldn’t report the tilt value at all. I asked Shelly support. Their answer: they can’t support individual smart home systems, and other Matter controllers such as Apple Home handle this behavior just fine. A fair point – so the fix had to happen in Home Assistant.

The fix

My pull request home-assistant/core#182042 changes two things in the Matter integration with 17 lines of code:

The tilt value is optional instead of required during discovery. If it’s empty, a cover entity is still created.
The tilt slider only appears if the device’s FeatureMap reports tilt – otherwise you’d get a slider that does nothing.

On top of that: tests with a simulated Shelly and real-world tests on my own devices (with and without slats, calibrated and uncalibrated). Submitted Saturday evening, merged Sunday morning: after more than a year of an open issue, the review took less than 17 hours.

My first pull request for Home Assistant – merged.

What you need to do now

Update Home Assistant to 2026.9.3 or later. The fix is listed in the release notes under 2026.9.3.
Calibrate your Shelly: start a calibration run in the Shelly web interface. Without calibration, no cover entity appears even with the fix.
If the shutter still doesn’t show up: in the device view, open the three-dot menu and run “Re-interview device”.

If you have venetian blinds: I show how to set up slat control and use it in automations in Tilt Venetian Blind Slats to the Percent with Shelly and Home Assistant.

Your opinion matters

That an uncalibrated Shelly doesn’t show up as a shutter via Matter at all is confusing, especially for beginners. Should Home Assistant create it anyway – at least with up, down and stop? Or is “calibrate first” perfectly fine? Tell me in the comments. If many of you agree, I’ll look into it next.

Products from this article

Shelly 2PM Gen4 – directly from Shelly (paid link): https://upf.ai/l24blt88 · discount code SMARTHOMEABERSICHER-10OFF for 10% off

b-parasite: Have an Open-Source Soil Moisture Sensor for Home Assistant Manufactured

Thu, 24 Sep 2026 00:00:00 +0000

Ad: Links to PCBWay are affiliate links.

For me, the b-parasite is the best soil moisture sensor there is – and you can’t buy it anywhere. No manufacturer, no shop. There’s only a blueprint, free on GitHub. I had ten of them made, and here I’ll show you the whole journey: from the blueprint to the flower pot.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The video is in German with English subtitles.

What is the b-parasite?

The b-parasite is an open hardware project: a PCB whose lower half works as a capacitive soil moisture sensor. It also carries a temperature and humidity sensor (SHTC3) and a phototransistor for brightness.

At its heart is a Nordic nRF52840 in an E73 radio module. Unlike the usual ESP controllers it has no Wi-Fi, but Bluetooth Low Energy – which makes it extremely power-efficient. A single CR2032 coin cell lasts for many months.

The firmware transmits using the BTHome v2 standard, which Home Assistant understands without any extra integration.

Getting to a finished sensor takes four steps:

Have the board manufactured and assembled
Flash the firmware
Set up a Bluetooth gateway for Home Assistant (e.g. a Shelly)
Coat the board against moisture

Step 1: Ordering the board – no KiCad skills required

I can’t use KiCad, and faced with an order form of 30 options – copper weight, solder mask, surface finish – I wouldn’t know what to pick. The good news: you don’t have to create the manufacturing files yourself, and almost every option stays at its default. Below is exactly what I ordered, step by step.

My recommendation: add the assembly service (PCB+Assembly). The SMD parts are only millimetres in size – not something you just solder yourself – and you don’t have to buy them separately.

How to place the order

1. Get the files. I’ve bundled everything PCBWay needs into one package: b-parasite-2.0.0-pcbway.zip (80 KB). It contains:

gerber.zip – the manufacturing data for the board, the way PCBWay wants it
parasite.csv – the bill of materials (BOM)
parasite-top-pos.csv – the centroid/pick-and-place file

The files are taken unmodified from Raphael Baron’s kicad folder (hardware version 2.0.0) and, like the original, are licensed under CC BY-SA 4.0. I only repackaged them because GitHub doesn’t offer downloads of individual folders.

2. Create the PCB. Sign in via my PCBWay link. The link takes you to the home page; the order form is under PCB Instant Quote in the top menu. The only things to fill in are size (22 × 126.4 mm) and quantity (e.g. 10, minimum is 5 boards). I left everything else at the defaults (2 layers, FR-4 TG150, 1.6 mm thickness, 6/6 mil track/spacing, 0.3 mm min. hole, green solder mask with white silkscreen, HASL with lead, 1 oz copper).

About the surface finish: With HASL I ran into the battery pad issue described further down. According to PCBWay, ENIG (immersion gold) avoids it altogether. It roughly doubles the board price, though – for ten boards from about 18 to about 40 US dollars. I’d stick with HASL and rough up the pad if needed.

3. Add assembly. Further down on the same page, tick Assembly Service and choose these options:

Turnkey – PCBWay sources all parts
Assembly side: Top side
Quantity: the same as for the boards. My order initially had 5 boards and 20 assemblies, which cost me a round of questions.
everything else (function test, conformal coating, firmware loading …) set to “No”

4. Upload the files. Don’t bother looking for an upload field up to this point: PCBWay only asks for the files after the price calculation. So click Calculate and then Save to Cart. The next page is where you upload the gerber.zip, the BOM (parasite.csv) and the centroid file (parasite-top-pos.csv).

5. Don’t forget the battery holder. The coin cell holder sits on the bottom side and has no part number in the BOM. PCBWay still fitted it on my boards, using the type Raphael recommends as well. To make sure yours get it too, add this to the order note:

1

Please also assemble BT1 (battery holder, bottom side): MYOUNG MY-2032-05, LCSC C964829

6. Wait for the quote. At PCBWay, a person reviews assembly orders. After a few days you get a quote with an itemised BOM, possibly with questions. Then you pay via the shopping cart.

7. Check the approval photos. Before final soldering, PCBWay sends photos of the assembled boards. Pay particular attention to the orientation of D2 (LED) and Q4 (phototransistor) – PCBWay had marked exactly these two in my photos. According to the b-parasite wiki, the phototransistor’s collector goes to the dot on the silkscreen.

What does it cost?

For ten assembled boards you end up at roughly 20 US dollars per sensor, including shipping. About half of that is the E73 radio module with the nRF52840, which alone costs around 10 dollars.

Lead time: Manufacturing alone takes only a few days. With assembly, it took two to three weeks including shipping in my case.

Pitfall: no voltage at the battery pad

First coin cell in – and nothing happened. No LED, no Bluetooth. The multimeter showed a perfectly good cell, but hardly any voltage reached the board.

Looking into the battery holder from the side revealed small bumps on the large battery pad – enough to keep the coin cell from sitting flat. Together with PCBWay support, who responded very quickly, the cause was clear: residue from the production process.

Fix: Carefully rough up the pad once with very fine sandpaper. After that, battery power works.

Step 2: Flashing the firmware with an ESP32

The author provides precompiled firmware in the releases. For the assembled hardware version 2.0.0 you need:

blinky_nrf52840_2.0.0.hex – test firmware, the LED blinks
ble_nrf52840_2.0.0.hex – the actual sensor firmware (BTHome)

The nRF52840 is programmed via SWD. Professional programmers are expensive – the cheaper route is the open-source project ESP32_nRF52_SWD, which turns an ESP32 into an SWD flasher with a web interface. It was written by the same developer behind the OpenOBI firmware.

Wiring according to the project:

b-parasite (nRF52)	ESP32
SWDCLK	GPIO 21
SWDIO	GPIO 19
GND	GND
VCC	3V3

Two rules before you start:

Only one power source: either the coin cell or the 3.3 V from the ESP32 – never both at the same time.
Erase first: The flasher doesn’t erase memory automatically. Run Erase before flashing.

I always flash in two steps: first Blinky – if the LED blinks, wiring and contacts are fine. Then the BLE firmware. This saves troubleshooting time.

During upload a white window with an hourglass appears – that’s normal. It’s done when the inconspicuous message completed shows up.

Tip: convert HEX to BIN

The flasher accepts HEX uploads, but they take several minutes. HEX files are text-encoded and much larger than the actual data. As BIN (offset 0), the same content flashes in seconds – a real difference with ten boards.

1
2
3
4
5
6
7


# using the Python tool intelhex
pip install intelhex
hex2bin.py --pad=FF ble_nrf52840_2.0.0.hex ble_nrf52840_2.0.0.bin

# alternatively with objcopy from the ARM toolchain
arm-none-eabi-objcopy -I ihex -O binary --gap-fill 0xFF \
 ble_nrf52840_2.0.0.hex ble_nrf52840_2.0.0.bin

Did it work? Unlike Blinky, the BLE firmware doesn’t blink continuously – it’s meant to save power. After a reset the LED blinks twice, and the values then appear in Home Assistant.

Step 3: Adding it to Home Assistant

Home Assistant needs a Bluetooth gateway that receives BTHome packets. I use a Shelly Gen2 or newer:

In Home Assistant, open the Shelly device and click the gear icon.
Set the Bluetooth scanner mode to at least passive (active works too) and confirm.
Wait for the sensor’s next measurement cycle – or briefly press the button on the board.

The b-parasite then shows up under discovered devices. Once added, it provides these entities:

Soil moisture
Temperature
Humidity
Illuminance
Voltage and battery level

All ten of my boards worked right away.

Device called “E73…” instead of “b-parasite”? Some of my sensors first appeared under the radio module’s name. That’s purely cosmetic – all values arrive. You can rename the devices yourself; in my case Home Assistant eventually named them correctly anyway.

Step 4: Coating against moisture

The project wiki explicitly warns against putting the board into soil uncoated: moisture can creep under the solder mask and cause corrosion.

So I spray the lower half with a plastic-based protective coating: top side, 20 minutes to dry, flip, bottom side, another 20 minutes. A simple cardboard mask keeps the upper half with the electronics and battery holder free.

If you prefer something more enclosed, the repository also has 3D-printable cases. I think the bare boards look cooler – a matter of taste.

Hands-on test: how good are the readings?

Moisture percentage is not an absolute value

The percentage is not universally calibrated. The only certainties: dry in the air the sensor reads 0 %, in a glass of water 100 %. Everything in between depends on soil type, compaction, how the sensor sits and how moisture is distributed.

Over several weeks, though, you can nicely see the soil slowly drying out – and every watering as a steep rise. Just moving the sensor to a different spot in the pot changed my reading by about 10 percentage points.

For automations this means: don’t rely on a fixed threshold like “water below 20 %” – set the threshold individually per plant and sensor.

Battery life: extrapolation doesn’t work

The author mentions up to two years of runtime in the repository. Some of my sensors have been running since April and have lost about 18 mV of their initial voltage.

A linear extrapolation gave almost 23 years for one sensor and 0.8 years for another. Both are nonsense: a CR2032’s voltage doesn’t drop linearly. It stays almost flat for a long time and then falls off steeply at the end. Depending on where on that curve you measure, the extrapolation gives wildly different results.

A better approach is a Home Assistant trigger on a minimum voltage that reminds you to change the battery in time.

Radio gaps

The sensor transmits every 10 minutes. In my setup roughly every tenth packet didn’t arrive, and the biggest gap in the log was about an hour. For a plant sensor that’s no problem – soil doesn’t dry out in an hour.

Verdict: is it worth the effort?

If you only want to know whether your plant is thirsty: probably not. A ready-made sensor is less hassle – for example the Zigbee soil moisture sensor from my hands-on test.

But if you want a sensor that

lasts a very long time on a coin cell,
runs open firmware nobody can shut down,
works fully locally – no cloud, app or account,
and simply shows up in Home Assistant,

then for me the b-parasite is the best soil moisture sensor you can get. You just have to have it built.

The effort in concrete terms:

Step	Effort
Ordering and waiting	2–3 weeks, hardly any work
Flashing	about 1–2 hours for ten devices
Coating	about 30 minutes for the whole batch

Giveaway: 3 b-parasite sensors

I’m giving away three sensors from this batch. To enter: like the video on YouTube, subscribe to the channel and reply under the pinned comment explaining why you’d like to win one.

Links

b-parasite on GitHub (repository, wiki, releases, cases)
ESP32_nRF52_SWD – SWD flasher for nRF52
BTHome integration in Home Assistant

Ad: I earn a commission via my PCBWay link at no extra cost to you. PCBWay had no influence on the content of this article.

Tilt Venetian Blind Slats to the Percent with Shelly and Home Assistant

Thu, 17 Sep 2026 00:00:00 +0000

Don’t just move your external venetian blinds up and down with Shelly and Home Assistant – tilt the slats precisely, to the percent. For years this only worked with ugly workarounds. Since firmware 1.5.0 (early 2025), Shelly devices from Gen2 onwards support it natively. I overlooked the feature for more than a year and only found it because of a bug somewhere completely different – today I’m a big fan. Here’s how to set it up, plus the two automations that only flash by in the video, complete and ready to copy.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Position and tilt: two independent values

With slat control enabled, a cover entity in Home Assistant has two values:

Value	Meaning	0 %	50 %	100 %
Position (`current_position`)	Height of the blind	fully closed	half	fully open
Tilt (`current_tilt_position`)	Slat angle	slats pointing down	horizontal	slats pointing up

The key point: the blind stays at a fixed height, and you still control exactly how much light and sun gets through – purely via the slat angle. In the video I show this on my office blind with a Shelly Plus 2PM: I only move the tilt from 20 to 50 to 80 %, and the height stays the same the whole time.

Backstory: my ugly workarounds

This wasn’t always possible natively. My south-facing windows originally had four Shelly 2.5 – first-generation devices that still don’t support tilt. My workaround back then: four custom switches in Home Assistant that sent a very short pulse via the Shelly REST API, 200 milliseconds up or down, to move the slats somewhat precisely. Yes, it was every bit as hacky as it sounds.

Later I replaced them with second-generation devices – but completely missed the new feature in early 2025. My wake-up routine had a similar trick (more below). By now I’ve thrown all of that out.

Shelly setup: Slat Control

In the Shelly web interface: Cover → Settings → Slat Control.

Open Time / Close Time: how long a full slat rotation takes (all the way down to all the way up). Shelly suggests 1.5 s – mine is 1.1 s. Adjust this to your blind, otherwise the calculated percentages will be off.
Don’t confuse this with the regular travel-time calibration of the blind. That one runs automatically; the slat time has to be entered manually.
Retain Slat Position: keeps the slat angle when the blind moves. If tilt is at 50 % and you move the blind halfway up, Shelly restores 50 % afterwards.
Precise Slat Position: according to the docs, this makes slat control even more precise. I haven’t noticed any difference in daily use – if you know what it actually does, let me know in the comments.

The wall switch behaves differently, too: a short press now only moves the slats (in 20 % steps), a long press moves the whole blind as usual. A short press while moving stops it.

How I found the feature: a Matter bug

I didn’t discover Slat Control on my blinds but somewhere completely different: I’m currently testing the new Shelly Gen4 devices, including their Matter support. If you add a Shelly to Home Assistant via Matter and Slat Control is not enabled, Home Assistant doesn’t create a cover entity at all.

The reason: Shelly then reports no value for tilt – null in programming terms, not to be confused with the number 0. That’s exactly what trips up Home Assistant’s Matter integration. As soon as Slat Control is enabled, a real number arrives and the cover entity shows up normally. While debugging this, I came across the setting for the first time.

Update: I contributed a bugfix to Home Assistant for this, shipping with HA 2026.9.3. More on that – and on Matter and Zigbee with the Gen4 devices – in my upcoming videos.

In Home Assistant: attribute and action

Read: attribute current_tilt_position on the cover entity
Set: cover.set_cover_tilt_position – analogous to cover.set_cover_position

1
2
3
4
5


action: cover.set_cover_tilt_position
target:
 entity_id: cover.office_blind
data:
 tilt_position: 50

Important: move first, wait, then tilt

In theory Home Assistant can combine position and tilt in one call, but not every device handles that cleanly – it caused problems for me. So:

Move the blind (cover.close_cover or cover.set_cover_position)
Wait until it has arrived (wait_template)
Only then call cover.set_cover_tilt_position

Without the wait, the commands can override each other and the blind ends up in a state you never wanted.

Automation 1: sun protection based on the sun’s position

My setup consists of two blueprints. The YAML is identical to the German version of this article – labels and descriptions inside the blueprints are in German.

Blueprint A: is the sun hitting the window?

This blueprint turns on an input_boolean per window front (e.g. input_boolean.sudfenster_beschienen) as soon as the sun actually shines onto the glass. It takes into account the compass direction, the orientation of my house (offset: 23 degrees) and the roof overhang: if the sun is high enough, the overhang shades the window and nothing needs to close.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


blueprint:
 name: Fensterbescheinung berechnen
 description: Berechnet ob für eine bestimmte Himmelsrichtung die Sonne auf die Fenster scheint
 domain: automation
 input:
 target_azimuth:
 name: Himmelsrichtung
 description: Die zu betrachtende (ideale) Himmelsrichtung
 selector:
 select:
 options:
 - value: "0"
 label: Nord
 - value: "90"
 label: Ost
 - value: "180"
 label: Süd
 - value: "270"
 label: West
 boolean_entity:
 name: Zustandsschalter
 description: Eine Entity die auf "ein" geschaltet wird, wenn die Sonne auf die Fenster scheint
 selector:
 entity:
 domain: input_boolean
trigger:
 - platform: state
 entity_id:
 - sensor.sun_solar_elevation
condition:
 - condition: numeric_state
 entity_id: sensor.sun_solar_elevation
 above: -1
action:
 - variables:
 target_azimuth: !input target_azimuth
 offset: 23 # house orientation offset from true compass direction
 azimuth: "{{ states('sensor.sun_solar_azimuth')|float }}"
 elevation: "{{ states('sensor.sun_solar_elevation')|float }}"
 roof_overhang: 86 # roof overhang in cm
 window_height: 200 # window height in cm
 - if:
 - condition: template
 value_template: |-
 {% set target_azimuth = target_azimuth|int + offset %}
 {% set delta = (target_azimuth - azimuth)|abs %}
 {{ delta < 90 or delta > 270 }}
 - condition: template
 value_template: >-
 {% set target_azimuth = target_azimuth|int + offset %}
 {% set degrees = 90-(azimuth-target_azimuth)|abs %}
 {% set effective_roof_overhang = roof_overhang / sin(degrees / 180 *
 3.1415) %}
 {% set max_elevation = (atan(window_height/effective_roof_overhang)) /
 3.1415 * 180 %}
 {{ 0 < elevation and elevation < max_elevation }}
 then:
 - service: input_boolean.turn_on
 data: {}
 target:
 entity_id: !input boolean_entity
 else:
 - service: input_boolean.turn_off
 data: {}
 target:
 entity_id: !input boolean_entity
mode: single

sensor.sun_solar_azimuth and sensor.sun_solar_elevation come from the built-in Sun integration (you may need to enable them). Adjust offset, roof_overhang and window_height to your house.

This blueprint reacts to the input_boolean from blueprint A: when the sun hits the window, the blind closes, waits until it’s really closed and then tilts the slats to the configured value. When the sun moves away, it opens again – but only if the automation closed it in the first place.

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124


blueprint:
 name: Rollos nach Sonnenstand schliessen und öffnen
 description: Schliesst und öffnet Rollos abhängig von einer Boolean Entity und optional Fensterkontakten
 domain: automation
 input:
 sun_hits_window_entity:
 name: Sonnenstandsindikator
 selector:
 entity:
 domain: input_boolean
 window_open_entity:
 name: Fensterkontakt
 default: []
 selector:
 entity:
 domain: binary_sensor
 cover:
 name: Rolladen
 selector:
 entity:
 domain: cover
 add_conditions:
 name: Weitere Bedingungen
 default: []
 selector:
 condition:
 tilt_after_close:
 name: Tilt nach dem Schliessen
 description: >-
 Optional: Lamellen-Position (%), auf die nach dem Schliessen
 gekippt wird. Leer lassen, um den Tilt unangetastet zu lassen.
 default: -1
 selector:
 number:
 min: -1
 max: 100
 step: 1
 mode: slider
trigger:
 - platform: state
 entity_id:
 - !input sun_hits_window_entity
 from: "off"
 to: "on"
 id: sun_true
 - platform: state
 entity_id:
 - !input sun_hits_window_entity
 from: "on"
 to: "off"
 id: sun_false
 - platform: state
 entity_id: !input window_open_entity
 from: "on"
 to: "off"
 id: closed
 - platform: state
 entity_id:
 - binary_sensor.sonne_scheint
 from: "off"
 to: "on"
 id: brightness_level
condition: !input add_conditions
action:
 - choose:
 - conditions:
 - condition: trigger
 id:
 - sun_true
 - closed
 - brightness_level
 - condition: state
 entity_id: !input sun_hits_window_entity
 state: "on"
 - condition: state
 entity_id: !input cover
 state: open
 - condition: template
 value_template: >-
 {{ cover not in
 states.sensor.automation_cover_state.state }}
 alias: Cover wurde heute noch nicht automatisiert geschlossen
 - condition: state
 entity_id: !input window_open_entity
 state: "off"
 - condition: state
 entity_id: binary_sensor.sonne_scheint
 state: "on"
 sequence:
 - service: cover.close_cover
 data: {}
 target:
 entity_id: !input cover
 - if:
 - condition: template
 value_template: "{{ tilt_after_close|int(-1) >= 0 }}"
 then:
 - wait_template: "{{ is_state(cover, 'closed') }}"
 timeout:
 seconds: 60
 continue_on_timeout: true
 - service: cover.set_cover_tilt_position
 data:
 tilt_position: "{{ tilt_after_close|int(-1) }}"
 target:
 entity_id: !input cover
 - conditions:
 - condition: trigger
 id:
 - sun_false
 - condition: template
 value_template: >-
 {{ cover in
 states.sensor.automation_cover_state.state }}
 alias: Cover wurde heute automatisiert geschlossen
 sequence:
 - service: cover.open_cover
 data: {}
 target:
 entity_id: !input cover
variables:
 cover: !input cover
 tilt_after_close: !input tilt_after_close
mode: restart

Two entities are specific to my house – replace or remove them:

binary_sensor.sonne_scheint (“sun is shining”) – a brightness sensor so nothing closes on cloudy days.
sensor.automation_cover_state – remembers which blinds were closed automatically today. That way the automation never opens a blind you closed yourself, and never closes one again that you opened manually.

Using the blueprint looks like this:

1
2
3
4
5
6
7
8


- alias: "Blinds: living room south – close/open based on sun position"
 use_blueprint:
 path: homeassistant/sun_close_blinds.yaml
 input:
 sun_hits_window_entity: input_boolean.sudfenster_beschienen
 window_open_entity: binary_sensor.window_contact_living_room_south
 cover: cover.blind_living_room_south
 tilt_after_close: 50

tilt_after_close: 50 sets the slats horizontal. Depending on the window and the incoming light, a different value may work better.

Automation 2: wake-up routine with daylight

My wake-up routine gently brings up lights and radio in the morning. The last step used to be an ugly hack: if the blind was fully closed, it was moved to position 1 % so some light could come through the slat gaps. It sort of worked, but it wasn’t real tilt.

Now the blind stays closed and only the slats are tilted:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


- alias: Tilt slats to 50% (if fully closed)
 if:
 - condition: state
 entity_id: cover.bedroom_blind
 attribute: current_position
 state: 0
 then:
 - alias: Set tilt to 50%
 action: cover.set_cover_tilt_position
 target:
 entity_id: cover.bedroom_blind
 data:
 tilt_position: 50
 continue_on_error: true

The current_position: 0 condition makes sure an already opened blind isn’t touched. continue_on_error prevents the whole routine from aborting if the Shelly happens to be unreachable.

The rest of the routine, in short:

10 minutes after the trigger: dim up the bedroom lights over 20 minutes (transition: 1200)
Set Sonos volume to 0 and start my favorite station – with up to 3 attempts until the player actually reports playing
Raise the volume in 8 steps, 2 minutes apart
Tilt the slats (see above)

My takeaway

The feature has been in the firmware since early 2025 – and it’s worth browsing your Shelly settings every now and then, even if you think you know your device inside out.

Two questions for you: do you know what Precise Slat Position actually does? And do you have blinds that could tilt, but you’re not using it yet? Let me know in the comments!

If you haven’t automated your blinds with Shelly at all yet, start with my article Make Blinds Smart with Shelly.

Ad: Want to get a Shelly? Use the code SMARTHOMEABERSICHER-10OFF for 10 % off via this link (affiliate link).

Shelly supplied the Gen4 devices briefly shown in the video free of charge. Shelly had no influence on the content of this article.

My Radio Mutes Its Own Ads

Thu, 03 Sep 2026 00:00:00 +0000

Half past six, bathroom, the radio is on. Music, news, traffic report — and then the first ad jingle of the day. It cuts off after a blink. Nobody pressed a button. The speaker muted itself.

Behind it is no language model detecting ads, no audio fingerprinting, no subscription service. Behind it is an automation with two triggers — and a station that voluntarily announces when ads are playing.

That’s the actual joke of the thing: I didn’t have to build the detection at all. SWR1 delivers it for free.

The station gives it away itself

Every radio station sends a small text channel alongside the audio. On FM, this is known as RDS radio text; on an internet stream, the same text arrives as title metadata. Whether the station taps the same source internally, I don’t know — all that matters to us is that the same text arrives at the speaker.

The crucial point: this text field is not a static station name. It changes constantly. On SWR1, a sample from a single morning included this, among other things:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


Walk of life / Dire Straits
Get lucky / Daft Punk feat. Pharrell Williams
I don't like Mondays / The Boomtown Rats
Something stupid / Robbie Williams & Nicole Kidman
Guten Morgen Baden-Württemberg mit Cora Klausnitzer & Matthias
SWR1 Baden-Württemberg Verkehrsservice
SWR1 Stau-Hotline: 0711-929 10 100
Aktuelle Nachrichten auch auf swr1.de
Nachricht über die SWR1 App
SWR1 Baden-Württemberg
Werbung in SWR1 ← the marker everything listens for

Song title, artist, presenter, traffic report, phone numbers — and right in the middle, the announcement that ads are currently playing. The station says so because the field is maintained anyway. Nobody thought that someone would build a mute automation on top of it.

My Sonos speaker reads this metadata from the stream, and the Sonos integration passes it into Home Assistant as the media_title attribute. That makes the ad block a perfectly normal state change in the system — and everything Home Assistant can do with state changes now works for radio ads too.

The signal chain is short:

1
2
3
4
5
6


SWR1 broadcast
 └─ Radio text in the stream ("Werbung in SWR1")
 └─ Sonos speaker reads the stream metadata
 └─ Sonos integration exposes it as the media_title attribute
 └─ Automation triggers on the exact text
 └─ media_player.volume_mute

Step 1: Find your station’s marker

This is the most important section of this article, because Werbung in SWR1 works exclusively for SWR1 Baden-Württemberg. Other stations phrase it differently, or don’t send a marker at all. Before you build anything, you need to check what your station actually sends.

Here’s how:

Play your target station on the speaker you want to control later.
In Home Assistant, open Developer Tools → States.
Find your media player entity, e.g. media_player.bathroom.
Watch the media_title attribute column while an ad block plays.
Note the text exactly: capitalization, spaces, special characters. The trigger compares character by character.

Faster: use Developer Tools → Template. This line shows you the live radio text without hunting through a long attribute list:

1

{{ state_attr('media_player.bathroom', 'media_title') }}

If you don’t want to sit next to the screen and wait for the next ad block, mirror the radio text into a template sensor. It then shows up in history, and you can review at your leisure what ran through over the day:

1
2
3
4


template:
 - sensor:
 - name: "Radio Text Bathroom"
 state: "{{ state_attr('media_player.bathroom', 'media_title') }}"

If you can’t find a usable marker, that’s where it ends — your station simply doesn’t send the information. Annoying, but honestly the more likely outcome. I got lucky with SWR1.

Step 2: Two triggers, one `if`

Now comes the ingredient many people don’t have on their radar: Home Assistant can trigger on an attribute change, not just on a state change.

The state of my speaker is playing the entire time. It doesn’t change when the ad starts — audio keeps playing, after all. What changes is the media_title attribute. That’s exactly what the trigger listens for via the line attribute: media_title. Without it, the automation would never fire. If you’re still missing the trigger basics, start with Home Assistant A-Z: A for Automations.

The second trick is symmetry:

to: Werbung in SWR1 — the radio text changes to the marker: ads start, mute.
from: Werbung in SWR1 — the radio text changes away from the marker: ads are over, audio back on.

Two triggers, two IDs, one if. That’s all there is to it:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


blueprint:
 name: Mute Sonos on Ads
 description: Mutes playback when the RDS stream reports an ad marker
 domain: automation
 input:
 media_player:
 name: Media Player
 description: The media player entity to control
 selector:
 entity:
 domain: media_player

trigger:
- platform: state
 entity_id:
 - !input media_player
 attribute: media_title
 to: Werbung in SWR1
 id: mute
- platform: state
 entity_id:
 - !input media_player
 attribute: media_title
 from: Werbung in SWR1
 id: unmute
condition: []
action:
- if:
 - condition: trigger
 id:
 - mute
 then:
 - service: media_player.volume_mute
 data:
 is_volume_muted: true
 target:
 entity_id: !input media_player
 else:
 - service: media_player.volume_mute
 data:
 is_volume_muted: false
 target:
 entity_id: !input media_player

To install it, drop the file into your Home Assistant configuration under blueprints/automation/<your-name>/sonos_ad_mute.yaml, reload blueprints under Settings → Automations & Scenes → Blueprints, and create automations from it. How blueprints work in general is covered in Home Assistant A-Z: B for Blueprints. You can also just paste the content from trigger: onward as a normal automation and replace !input media_player with your entity.

Two notes on the code that I don’t want to withhold:

The syntax is the classic one. platform: and service: are the older form; newer Home Assistant versions prefer triggers: and actions:. The old form still works, and since this is my blueprint running in production, I’m showing it exactly as it sits on my system.

The else branch is deliberately simple — and exactly for that reason a dead end. It unmutes on every trigger that isn’t mute. With exactly two triggers, that’s clean. As soon as you add a third, it unmutes too, and you get a bug that takes a while to find. Anyone extending this should turn the if/else into a choose beforehand. I collect this kind of pitfall in 5 Automation Mistakes Everyone Makes in Home Assistant.

If your station isn’t quite so unambiguous

For SWR1, the text is always identical, so an exact comparison is enough. If your station sends varying text — say, with an appended timestamp or changing wording — you need a trigger that checks for a text fragment instead of the whole string:

1
2
3
4
5
6
7
8
9


trigger:
- platform: template
 value_template: >
 {{ 'Werbung' in (state_attr('media_player.bathroom', 'media_title') or '') }}
 id: mute
- platform: template
 value_template: >
 {{ 'Werbung' not in (state_attr('media_player.bathroom', 'media_title') or '') }}
 id: unmute

Warning: this variant is not running for me — I don’t need it. It’s the obvious path, but untested. If you build it, check especially that the word doesn’t accidentally show up in song titles or programme announcements too. Otherwise your radio happily mutes itself during a segment about advertising agencies.

One automation per speaker

The blueprint is instantiated five times for me — once per room:

Room	Entity
Office	`media_player.office`
Bedroom	`media_player.bedroom`
Bathroom	`media_player.bathroom`
Living room	`media_player.living_room`
Terrace	`media_player.terrace`

Looks like unnecessary copy-paste, but it’s necessary: on Sonos, muting is a property of the individual speaker. Even when several speakers are grouped together, each one has to be muted separately. Which is exactly what a blueprint is for — click five times, pick an entity five times, done. What else those five speakers draw in standby power, and how I switch them off at night, is covered in 5 Smart Home Automations: Saving Power with Home Assistant.

Ten days of recording: what does it actually do?

An automation like this quietly runs in the background, and after a few weeks you no longer notice whether it’s actually doing anything. So I evaluated my Home Assistant database, period August 17–27, 2026, i.e. ten days.

Result: 73 detected ad blocks — and the automation has worked reliably since it was set up. Not a single case where the marker was in the radio text and the mute didn’t fire.

Nearly all triggers cluster between 6 and 9 a.m.:

Hour	Ad blocks
06:00	44
07:00	15
08:00	4
12:00	2
13:00	6
18:00	2

Before you conclude that SWR1 airs particularly heavy morning advertising: these numbers don’t show that. They only show when I have the radio on — almost exclusively in the morning, as an alarm and breakfast companion. I have no data on how many hours I listen at which time of day, and without that denominator, the distribution isn’t evidence of ad timing, just a picture of my listening habits. What the numbers do show: whenever the radio is on, the automation fires reliably.

On block length: for 31 blocks a clean end could be measured, 30 of which fell within a plausible range.

Median: 117 seconds — just under two minutes per ad block
Mean: 97 seconds
Range: 17 to 150 seconds
Sum of these 30 blocks: roughly 49 minutes of silence over ten days

Scaling the median up to all 73 blocks lands around two hours — but that’s an estimate, not a measurement, so I’d rather quote the 49 minutes that actually show up in the data.

One quirk from the evaluation I’m keeping: one block clocked in at 2216 seconds, over 36 minutes. No ad block is that long. What actually happened: the speaker was switched off mid-ad, the radio text stayed put, and the end was only registered the next time it was switched on. Not a bug in the automation, but a good example of why you shouldn’t dump raw recorder data into a statistic unfiltered.

Where the limits are

So you know what you’re signing up for — five real limitations:

1. The marker is hard-coded and station-specific. Werbung in SWR1 applies to SWR1 Baden-Württemberg and nowhere else. Whether other SWR stations use the same text, I haven’t tested. That’s why the observation step above comes so early: it’s the actual work of rebuilding this.

2. It mutes, it doesn’t skip. The ad time keeps running, it’s just silent. On a live stream there’s no other way — there’s nothing to skip to.

3. Only radio streams with metadata. Spotify, music from your own library, or line-in have no such field. The whole approach depends entirely on a station voluntarily sending something.

4. One automation per speaker, as above.

5. The automation is in charge of the mute. If you mute your speaker yourself for your own reasons and an ad block ends during that time, the automation lifts your mute. That happens rarely and doesn’t really hurt, but the interaction isn’t thought through.

And one number I checked with a stopwatch instead of estimating: latency. How many seconds of ads get through before the audio drops depends on how quickly the speaker updates the stream metadata and the integration passes the event on. For me that’s on average one to two seconds — the ad jingle is just barely audible, then it’s quiet.

Conclusion

The appeal of this automation isn’t the automation itself. It’s trivial: two triggers, one branch, two lines of action.

The appeal is that a problem that sounds like it needs machine learning and audio analysis dissolves into thin air the moment you look in the right place. The information was there the whole time. It just sat in a field nobody looks at.

That’s a pattern that works more often in smart homes than you’d think: before you start detecting something, check whether someone is already telling you. Entity attributes are an underrated goldmine for this — and the fact that Home Assistant can trigger on them directly makes them immediately usable.

What’s in your media_title when your station plays ads? Tell me in the comments — I’m curious which stations else deliver this.

Make Your Doorbell Smart Without Disturbing the Neighbors (Siedle + ESPHome)

Thu, 27 Aug 2026 00:00:00 +0000

My doorbell is a completely normal, old Siedle intercom handset. No WiFi, no app, no cloud. And yet it pings my phone whenever someone rings — and I can open the door straight from Home Assistant. Here’s the catch: I’m not the only one on this system — four neighboring apartments in this building hang off the very same wiring. One wrong move, and I take down the whole building’s intercom. That’s exactly why I’m showing you here how to make any doorbell smart without bothering your neighbors — and the trick is simpler than you might think.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Why not just buy a ready-made solution?

Roughly every second intercom system in Germany is made by Siedle — so there’s a good chance you have one too. And if you don’t, the principle still carries over. Of course there are off-the-shelf solutions: the Nuki Opener, for example, is wired in parallel to the system and can then open the door. That means locking yourself into the Nuki and app ecosystem, needing an extra battery, and spending around €100. Or the official Siedle solution, the Siedle IQ HTS — that replaces the intercom handset entirely and hooks into the Siedle app. An expensive full swap, and you’re stuck in the manufacturer’s cloud.

Both work. But both mean depending on a manufacturer, a cloud that has to keep running, and handing over control. I wanted the opposite: a robust, local solution that still works in ten years — one no vendor can pull the plug on. So I built it myself.

The principle in one sentence

And here comes the single most important sentence of this whole project: you don’t need to understand the entire system — and you definitely don’t need to reverse-engineer the bus protocol. You only need to do two things: find the right signal, and electronically “press” the buttons that are already there.

Read (inputs): Is the front door ringing? Is the apartment door ringing?
Control (outputs): everything you could already operate directly on the device itself — in my case, the door opener and the stairwell light.

There’s no more magic to it than that. Exactly what the ring signal looks like technically varies from system to system, but the approach stays the same. I’ll show it to you concretely using my Siedle system as the example (intercom handset HTS 811-0, 1+n technology).

Detecting the ring: the voltage trick

How does the ESP detect that it’s ringing? Through the voltage on the line. At rest, my system sits at around 18 volts. When the front door rings, the voltage briefly jumps to 24 volts, the ringtone plays, and it drops to about 15 volts. The circuit detects exactly this jump.

I measured these exact values on my own system myself — on a different 1+n installation, the absolute values may vary depending on the power supply type, cable length, number of subscribers, or age of the installation. But the basic behavior — a stable resting voltage, a short peak when it rings, and a drop during the ring tone — is, according to Siedle’s own system manual, characteristic of the entire 1+n series, so it applies to every Siedle device using this technology. More on that in a detailed thread on mikrocontroller.net and in the Siedle system manual.

The trick in the circuit: a Zener diode in front of the optocoupler. It makes sure nothing gets through at rest — only at the ring peak does the optocoupler switch through, and the ESP knows: it’s ringing. I even distinguish between two different rings: the front door, and the apartment door bell right in front of the flat, the so-called floor call. That runs over its own terminal with AC voltage, so there’s a second optocoupler for that.

Opening the door: press the button instead of rebuilding the protocol

Now it gets really interesting. With Siedle’s 1+n system, “door open” isn’t transmitted digitally at all — it’s sent as a tone frequency, a whistle tone around 20 kilohertz that’s modulated onto the line. The outdoor station at the front door listens in, recognizes exactly this frequency with a filter, and then switches the door buzzer. The light button does the same thing, just with a different frequency.

I could try to somehow recreate and inject that frequency myself. But that only makes things needlessly complex, and I’d risk disturbing the whole system again. So instead I do it the other way around — and this is really the key trick: I simply press the existing door-opener button with my ESP. It closes the button’s contacts for a brief moment, like an extra finger. The handset itself then generates the whistle tone on the line, all on its own. I don’t need to understand the frequency at all — I just press the button. And that’s been working reliably for months, even with the handset hung up.

So I don’t damage the buttons while soldering, I don’t tap the signal directly at the buttons at all — instead, at two test points on the back of the circuit board that I found beforehand with a multimeter; they’re directly wired 1:1 to the buttons.

The hardware: compact and cheap

The hardware is pretty manageable: an ESP8266 NodeMCU as the microcontroller with WiFi, an LM2596 step-down converter that taps the ESP’s power supply straight from the system voltage — no extra power supply needed. Then there’s the coupling stage: optocouplers with resistors and a Zener diode for the two ring inputs, plus two transistors for the door-opener and light outputs. All soldered onto a small perfboard that fits easily inside the intercom handset’s housing — the original circuit board stays almost completely untouched right next to it.

The whole system is fed from a central Siedle power rectifier down in the basement, which delivers around 23 volts for the bus and 12 volts for the door buzzer. The few milliamps I tap off for my ESP don’t disturb the other devices in the other apartments at all.

ESPHome: three details that matter day to day

The software is ESPHome — two binary_sensors for the two bells, two switches for the door opener and the light. Sounds like about twenty lines of YAML, and it is. But three details decide whether this thing actually runs reliably day to day:

inverted — the optocoupler pulls the pin to ground, so active means low, not high. Instead of changing that in hardware, it’s a single line of YAML — plus a delay_on for debouncing, so a random glitch on the line doesn’t trigger a phantom ring.
The 500 ms pulse — the door opener isn’t a permanent switch, it’s a switch that turns itself back off. That’s not just a nice-to-have: if the WiFi drops out mid-action for whatever reason, the switch would otherwise stay on permanently and the door would stay open. The ESP simply counts down that half-second itself, completely without the network.
restore_mode + pin choice — restore_mode is set to “always off,” so the ESP doesn’t restore the last state after a power outage and unintentionally open the door. And the door opener and light sit on D1 and D2 — on the ESP8266, the pins that are guaranteed to do nothing during boot. A few other pins do change state briefly at startup, and the door would buzz briefly on every restart if wired to one of those.

There’s one thing I’d do differently today: my bell is wired to pin D4, and D4 is also one of those special pins that has to be high during boot. As an input, it’s run problem-free for months for me — but if it rang in the exact second the ESP restarts, it wouldn’t boot. In practice that’s basically never happened, and I’m not going to re-solder it now — but if you’re building this yourself, use D5 or D6 for the bell instead.

The payoff: four entities in Home Assistant

In Home Assistant I now have four entities: front door bell, apartment bell, door opener, and light. From those I can build whatever I want — a push notification to my phone when it rings, manually opening the door from the dashboard or by voice command, or automatically opening the door when a visitor knows the secret ring signal and presses the bell in the right rhythm.

Conclusion: a question of proportionality

Off-the-shelf solutions like the Nuki Opener or the Siedle IQ HTS aren’t bad — they’re just a different answer to a different priority: convenience and manufacturer support in exchange for money and a bit of control. My approach is deliberately minimally invasive: no bus reverse-engineering, no cloud, no intervention that could endanger other apartments in the building. Just two signals to detect and two buttons to press electronically — galvanically isolated, reversible, and for well under €20 in materials.

GitHub repo

My complete ESPHome config, the documentation, the voltage graph, the circuit diagram, and the labeled photos of my system are all in the GitHub repo:

➡️ github.com/jowi24/siedle-hts-811-esphome

If you also have a Siedle 1+n system, you can dive straight in. If you have a different one, use this as a starting point for your own solution — the tricks in this article should get you there quickly.

Now it’s your turn

Is your doorbell smart yet? Have you built something yourself, or are you rebuilding my approach right now — whether with Siedle or another system? Let me know in the comments how you’d extend this, and what automations you use with your own intercom. Improvement suggestions and pull requests for the repo are always welcome.

5 Home Assistant Automations That Save Energy

Thu, 20 Aug 2026 00:00:00 +0000

My router, speakers, AV receiver, and printer used to draw a combined 76 watts while doing nothing. If they ran around the clock, that would cost almost €180 per year at my electricity rate. This is where automations help me: not through one spectacular trick, but by preventing small amounts of wasted energy every day.

Here are five solutions from my actual home. Four reliably reduce my energy costs. The fifth sounded sensible but provided no benefit with my heat pump, so I removed it again.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

1. Automatically switch off standby power hogs

My home currently draws around 55 watts of base load when idle. This includes devices that need to remain reachable for the smart home, such as Shelly modules, sensors, and my home server. I consciously accept that consumption.

Several other devices, however, used to stay on even when nobody needed them:

Device	Power	Annual cost if always on
FRITZ!Box router	16 W	almost €40
Five Sonos speakers	35 W	over €80
AV receiver	15 W	around €35
Printer	10 W	around €24

Together, these examples add up to 76 watts. My actual savings are lower than the theoretical €180 because I do not keep the devices off permanently. Home Assistant simply makes sure they are off whenever I do not need them.

When I leave the apartment, I long-press the hallway light switch. This deliberate “I’m leaving” signal switches off Sonos, the receiver, and the printer. The manual trigger is intentional: for this use case, I prefer an unambiguous button press over presence detection that occasionally gets it wrong.

I also switch off the FRITZ!Box at night. My smart home continues to run locally without internet access. I explain why local operation matters in Home Assistant A–Z: O for Offline.

There is a small downside: the Sonos speakers need about a minute after power-up, while the router takes roughly two minutes before everything is available again.

2. Run large loads on solar power

If you have solar panels, flexible high-power appliances should run whenever enough of your own electricity is available. In my home, this mainly applies to the washing machine and electric car.

My washing machine is connected to Home Assistant through Home Connect. In the morning, I load it, select a program, and enable remote start. Once around 2.5 kilowatts of surplus solar power are available, Home Assistant starts the machine automatically.

The car follows the same principle. My Heidelberg Energy Control wallbox is connected to the solar system through Home Assistant and evcc. The Cupra Tavascan charges primarily on surplus solar power unless a defined minimum state of charge takes priority. Of the roughly 3,500 kilowatt-hours the car uses each year, about 1,500 kilowatt-hours come from my own roof despite my relatively small solar array.

3. Get reminded to ventilate efficiently

Leaving a window open for too long wastes heating energy in winter. With a heat pump, that directly becomes additional electricity consumption. I therefore monitor the windows I regularly open using six Homematic contact sensors. The outdoor temperature comes from my heat pump sensor via Modbus.

My simple rule, deliberately tailored to my home, is:

Below 5 °C: send a reminder after 5 minutes
Between 5 and 15 °C: use the temperature as the number of minutes
Above 15 °C: do not send a reminder

If a window remains open beyond that limit, the Home Assistant app sends a push notification. This prevents forgotten windows without creating unnecessary alerts during mild weather. These values are not a universal ventilation formula; they are thresholds that work well for my building.

Bonus: Automate the electricity price too

Automations can reduce consumption or shift it to times when your own solar power is available. Another factor is the price per kilowatt-hour. During my most recent provider switch, I saved 5 cents per kilowatt-hour and received an additional €250 switching bonus.

The remind.me switching service checks once a year for the best suitable electricity, gas, or heat-pump tariff and prepares the switch. New-customer bonuses are included, and you have the right to veto every switch.

👉 Learn more about the remind.me switching service

4. Why I removed night setback

Turning down the heating at night sounds like an obvious way to save energy. Whether it works depends on the building, heat emitters, heat source, and control system.

In a poorly insulated older building with conventional radiators, night setback can indeed save energy. With my combination of a heat pump, underfloor heating, and a high-mass screed floor, however, the room temperature barely drops overnight. If the controller then catches up in the morning using a higher flow temperature, that less efficient operation can consume the small theoretical saving.

Night setback provided no measurable benefit in my setup, so I removed the automation. The better rule is not to apply it blindly, but to compare actual consumption over equivalent periods.

5. Shutters save energy in summer and winter

My shutters close automatically based on the position of the sun. This saves energy in two ways:

In summer, they keep solar heat outside, reducing the work required from an air conditioner.
In winter, closed shutters add another layer in front of the windows at night, reducing heat loss and the amount of electricity required by the heat pump.

I explain how to create sun-dependent shading with Home Assistant blueprints in Home Assistant A–Z: J for Shutters.

Conclusion

None of these automations is a revolution on its own. Together, however, they prevent unnecessary standby consumption, make better use of solar power, and reduce wasted heating or cooling energy. Once configured, most of them run almost entirely by themselves.

Night setback is the important counterexample: an automation does not automatically save energy just because it is commonly presented as an energy-saving tip. What matters is what it actually does in your home.

Which smart home automation saves the most energy for you – and which supposed energy-saving trick did you switch off again?

OBI Energy Tracker Fully Local: OpenOBI Without the Cloud

Thu, 13 Aug 2026 00:00:00 +0000

The OBI Energy Tracker is an inexpensive way to read a smart electricity meter. Out of the box, however, its readings pass through the heyOBI app and OBI’s cloud. The open-source OpenOBI firmware lets you run the bridge entirely on your local network: the reader still communicates over LoRa, the bridge provides a local dashboard, and Home Assistant receives the data from your own MQTT broker.

This guide covers the complete migration. The initial setup is fairly technical, but once it is finished, the OBI app, OBI cloud, and HACS integration are no longer required.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What you need

OBI Energy Tracker bridge and optical reader
computer with Python 3, Bluetooth, and access to the bridge’s network
TCP port 8883 available during setup
valid heyOBI login to retrieve the device-specific TEA key
local MQTT broker, such as Home Assistant’s Mosquitto add-on
project files from atc1441/OBI_Energy_Tracker_Local_Cloud

If you only want to see the readings in Home Assistant and do not mind using OBI’s cloud, the HACS integration by mla157 is the easier route. This guide deliberately uses the fully local open-firmware approach.

How the local data path works

The optical reader collects OBIS values such as imported energy, exported energy, and current power from the meter. It sends them to the bridge over 868 MHz LoRa. The ESP32-C3-based bridge normally forwards those readings to the manufacturer’s cloud service.

During the migration, a computer briefly takes over the role of that cloud. The bridge receives Wi-Fi credentials, certificates, and the temporary MQTTS server address over Bluetooth. It then downloads OpenOBI as a regular over-the-air update. This helper server is not needed afterward: OpenOBI publishes directly to your permanent MQTT broker.

1. Prepare the environment

Clone the project, open the 04-connect-your-own-cloud directory, and create a virtual Python environment. Then install the three required packages:

1
2
3


python3 -m venv .venv
source .venv/bin/activate
pip install cryptography bleak paho-mqtt

Use a Bluetooth Low Energy scanner to find the bridge’s full name. It starts with OBI- but is not printed on the enclosure.

2. Retrieve the TEA key

In the tools directory, run the helper and enter your heyOBI login and the bridge’s Bluetooth name when prompted:

1
2


cd tools
python fetch_tea_key.py

The result is the device-specific, 32-character TEA key. It authorizes Bluetooth configuration changes, so treat it like a device password and never publish it.

3. Generate certificates and start the temporary server

Generate the certificates using the local IP address of the computer that will host the temporary server. The bridge must be able to reach this address, and it should not change during the process.

1

python gen_certs.py --host <LOCAL-BROKER-IP>

The script creates certificates and ble_config.json in the pki directory. In a second terminal, start the included MQTTS server and leave it running:

1

python mqtts_server.py --host 0.0.0.0 --port 8883

This helper emulates only the cloud functions required for provisioning and OTA. It is not a replacement for the permanent Mosquitto broker used later.

4. Move the bridge over Bluetooth

Hold the bridge button for more than two seconds to enter Bluetooth setup mode. Then transfer the configuration, TEA key, and Wi-Fi credentials:

1
2


python ble_provision.py --config pki/ble_config.json --key <TEA-KEY> --unbind \
 --ssid <WIFI-NAME> --password <WIFI-PASSWORD>

--unbind removes an existing association with the OBI account. The original firmware reliably handles Wi-Fi passwords only up to 32 bytes. If the bridge does not connect despite correct credentials, check the password length first.

After provisioning, the original firmware searches for the optical reader. Hold the reader’s large orange button for more than ten seconds and select it in the terminal. You can skip this step when your only goal is the firmware update by adding --no-pair-sensor.

CONNECT in the server log confirms that the bridge reached the local computer. If an EnergyTrackingSensor message with a real energy value also appears, the reader and LoRa link are working as well.

5. Install OpenOBI over the air

Download the current firmware image from the project’s release page. Only the file containing obi_gateway_c3 is intended for the original OBI bridge.

Stop the temporary server and restart it with the path to the firmware image:

1
2


python mqtts_server.py --host 0.0.0.0 --port 8883 \
 --ota-firmware <PATH-TO-OBI_GATEWAY_C3-FIRMWARE>

The bridge downloads the image in blocks. Do not interrupt power or network access until it reaches 100 percent and reboots. OpenOBI is then running, and its local dashboard is available at the IP address assigned by your router.

6. Bind the reader in OpenOBI

The reader initially appears dimmed and unbound in the dashboard. Select Bind to gateway for that specific reader. OpenOBI does not require another button press on the reader.

Once bound, the dashboard shows imported energy, exported energy, current power, battery voltage, and radio diagnostics such as RSSI and SNR. You can also choose the reporting interval: Live provides fast updates, while longer intervals conserve the reader’s battery.

7. Connect Home Assistant through MQTT

Under Settings > MQTT, enter the address of your permanent MQTT broker. In a typical Home Assistant installation, this is the Mosquitto add-on. Plain MQTT usually uses port 1883 and MQTTS port 8883. The username and password belong to your own broker, not your heyOBI account.

The base topic can remain obi/gateway. Enable MQTT Discovery and save the connection. The OpenOBI dashboard should then report a connected status.

Home Assistant automatically creates two MQTT devices: the LoRa gateway and the optical meter reader. Their energy sensors have the correct units and device classes, so they can be used directly in the Energy dashboard and automations. No HACS package, YAML, or custom templates are required.

Troubleshooting

The bridge is found over Bluetooth but cannot be configured: Hold its button for more than two seconds immediately before running the command.
No Wi-Fi connection: Verify the SSID and password; the original firmware accepts no more than 32 bytes for the password.
No CONNECT in the server log: Check the local IP address, firewall, and reachability of port 8883.
Wrong firmware image: Use only an image containing obi_gateway_c3 for the original bridge.
Reader remains unbound: Bind your specific reader in the OpenOBI dashboard and check its radio values.
No devices in Home Assistant: Verify the broker credentials, base topic, and MQTT Discovery setting.

Conclusion

After this one-time migration, the complete measurement path stays on your network: the reader transmits to the gateway, OpenOBI publishes to the local MQTT broker, and Home Assistant processes the values without a manufacturer cloud. The temporary server and heyOBI login are no longer needed.

For a look at the original app and cloud experience, read my OBI Energy Tracker review.

Disclosure: I bought the second Energy Tracker used for this conversion myself. The following product link is an affiliate link. If you buy at the regular price, I receive a commission at no additional cost to you. The linked shop and product are intended for the German market.

👉 View the OBI Energy Tracker at OBI

Drip Irrigation Holiday Test: How 20 Liters of Water Ended Up in My Living Room

Thu, 06 Aug 2026 00:00:00 +0200

I’m a Smart Home nerd through and through – and when I go on holiday, I’d love to have the watering of my plants automated as well. On my terrace an automatic drip irrigation system has been running for many years now; it works brilliantly and takes a lot of work off my hands. So the idea was obvious: use something like that indoors too – at least while I’m away. Finally no more bothering the neighbors!

What I didn’t realize back then: just how badly this experience would turn out. When I came back from holiday, my drip tray had flooded right to the brim – not because I had planned it that way, but because the irrigation system had drained my entire water supply onto the bottom of the tray. And – small teaser – that wasn’t even the only problem. Two things went wrong for me, and the second one is even far more annoying than the first.

Disclosure: The NEO Indoor Drip Irrigation Water Timer (NAS-WV08W) was provided to me free of charge by the manufacturer – with no conditions attached to the content. Because I received the device for free, I label this post as advertising. It doesn’t change my assessment, as you’ll notice in a moment.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The idea: watering by app while on holiday

I tested the NEO Indoor Drip Irrigation Water Timer (model NAS-WV08W) – a drip irrigation system for indoors, with a pump, hoses and app control. My test subjects were two plants in my living room: a poinsettia and a lucky clover.

Important, and in hindsight my rescue: I put the entire test setup into a drip tray. Pure precautionary instinct – without it my living room floor would have been flooded.

I set the system up about a week before the holiday. Originally I wanted to integrate it into Home Assistant, but I didn’t manage to get that running in the short time available – classic nerd problem: too little time, too much ambition. So for this first holiday I fell back on the manufacturer’s app: Smart Life (the well-known Tuya app). It runs through the cloud, but for a first test I thought to myself: that’ll be fine.

Second spoiler: it wasn’t fine.

First, the important part: the siphon principle

One thing I noticed during testing already – and you need to remember it, because it becomes important in a moment: The plant has to sit higher than the water tank.

Otherwise this is what happens: as soon as the hose outlet sits lower than the water level in the tank and the pump has run briefly, so that the hoses are full of water, water flows through the hose all by itself via the so-called siphon principle – drop by drop, even though the pump has long been off. So the pump does not stop the flow.

It’s the same trick you use to fill up a jerrycan from your neighbor’s car: once it’s going, the difference in height keeps pulling the liquid along by itself until the tank is empty.

That’s exactly what the manual says as well, and I set it up accordingly – plant on top, tank below – and during the test week everything worked flawlessly. Every time I tapped “water” in the app, it ran perfectly. Remember this section – it explains the mess later on.

Problem 1: the cloud was gone – and the app kept quiet

Then came the holiday, and with it problem number one. First look at the app while I was away: no cloud connection to the device.

What exactly caused it, I still can’t say for sure today. According to my DHCP server, the device did log into the Wi-Fi now and then, but apparently only sporadically. What really annoyed me, though, was something else:

The app never clearly showed me this connection problem. Instead – at least that’s how it looked to me – it had quietly fallen back to Bluetooth back home during testing, without telling me. At home everything worked over that connection, so nothing stood out. Only once I was away did that Bluetooth connection fail too, with an error message. And Bluetooth is of very little use when you’re a few hundred kilometers away.

For me that’s simply badly solved: an app should clearly show me a connection problem and not silently fall back to something that can’t work at all in a different situation. The result: I couldn’t control the device while on holiday at all.

Problem 2: 20 liters of water by pure physics

After the holiday I found problem number two – and this is where the siphon principle from earlier comes back into play.

The hose had come loose from the pump and was just lying on the bottom of the tray – so lower than the water surface in the canister. And you remember: as soon as the hose outlet sits lower than the water level, the water keeps flowing all by itself.

That’s exactly what happened. Through this very effect my entire water supply ran into the tray within a few minutes – no pump needed, the difference in height does it all by itself. 20 liters of water, almost completely drained. The drip tray was filled accordingly.

The cause: a missing barb

So the question remains: why did the hose come loose at all?

I took a close look at the construction afterwards – and found something: all the other plug connections on this device have little barbs that secure the hose. Only the connectors on the pump on my unit don’t. Since the device is new, I don’t assume wear is the cause – this important safety feature is simply missing.

To sum up, two things went wrong for me:

No remote control while on holiday, because the app obscured the connection problem rather than clearly showing it.
A hose that slipped off at exactly the spot where the safety feature that’s meant to prevent that is missing.

In the end, what got watered was: nothing except my tray.

What NEO says about it

After the holiday I confronted the manufacturer NEO with my experience and asked for a statement. On the plus side: NEO answered quickly and in detail – though not on every point the way I would have liked.

The pump: fixed – but only for new devices

NEO admits that the pump connector has been reworked and given a barb that secures the hose – so exactly the spot that failed on my unit. Sounds good at first.

The catch, quite literally: according to NEO, this improved connector only comes on new devices from upcoming production batches. For devices already in use – like mine, and maybe yours too – there is no replacement and no spare part, that would be too much effort.

Translated, that means: the manufacturer has fixed this spot – but anyone who already owns the device today is left empty-handed for now. Honestly, that’s the point that annoys me personally the most.

The app: the silent fallback is confirmed

For the app I asked very specifically: if the device falls back to Bluetooth – does the app actually tell the user?

NEO’s answer: no, it doesn’t – but they are working on an update that improves exactly this. As the cause of the switch itself, NEO suspects my home network. I can’t conclusively prove that everything at my place really was fine – there were no other incidents during that period though, and my Home Assistant watches closely.

For me, the question of the cause doesn’t change the core issue: no matter why the device switches to Bluetooth – the fact that it doesn’t show me and leaves me believing everything is running normally, that is the problem. And NEO confirms exactly that themselves.

That the manufacturer responded to both points so openly and so quickly is something I explicitly give them credit for – that’s far from a given.

What you can take away from this

Look closely. During setup I had already noticed that these barbs weren’t fitted everywhere – I just didn’t think anything more of it. A mistake.
Plan for the worst case. Putting a drip tray under the test setup was the best decision of the whole exercise.
Cloud control is not a sure thing. For anything safety-relevant (and water in the living room is exactly that), don’t blindly rely on an app that hides connection problems.

Conclusion

For me, the NEO NAS-WV08W disappointed on two counts: an app that hides the loss of the cloud connection behind a silent Bluetooth fallback, and a pump connector without the safety feature that every other connection has. Together they meant that nothing got watered while I was away – and that afterwards 20 liters of water were standing in the tray.

To be fair: NEO has recognized the design flaw at the pump and fixed it in production, and wants to deliver the missing app warning via an update. For existing devices that changes nothing in the short term – and that’s exactly where a manufacturer should go further, in my view.

Your opinion matters!

The open question for me remains: what do I do on my next holiday? I’d genuinely appreciate your tip or advice – and if you’ve had your own experience with smart (indoor) watering, please share it in the comments.

And if you haven’t had enough of plant topics: in my test of the NEO Zigbee soil moisture sensor I take a look at another device from the same manufacturer – with a considerably happier ending.

If you’d like to try a (different) irrigation solution yourself and support me along the way: this Amazon search for indoor irrigation* will find you plenty of alternatives. Or take a look at my partner OBI: indoor irrigation at OBI*. If you buy through these links, you’re helping this blog on the side.

(Affiliate links – through the partner programs of Amazon and other retailers I earn from qualifying purchases)

Thanks for reading – take care of yourself and your Smart Home!

Your Joachim

15-Year-Old Dishwasher, Smarter Than Home Connect

Thu, 30 Jul 2026 00:00:00 +0000

My dishwasher is a Siemens from 2010 – 15 years old, no WiFi, no app, no cloud. Exactly the kind of appliance you’d normally just replace at some point without a second thought. In my kitchen, though, Home Assistant shows me at any moment, to the minute, which program is running, how much time is left, whether the door is open, and whether I need to refill the salt – all of it locally, in my own house, without a single data packet ever leaving it.

Sounds like a relaxed afternoon of tinkering? It wasn’t. Along the way, one careless move fried the heart of the machine, and I had to pay €315 in “tuition” before a single dish came out clean again. How a “dumb” old appliance ended up doing more than plenty of new ones with Home Connect – and how you can skip the expensive detour – is what this post is about.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The idea: just listen in on what the machine says anyway

It all started with a talk at the Chaos Communication Congress – »Hacking washing machines«. Two security researchers showed how Miele devices, and BSH devices (Bosch, Siemens, Neff & co.), tick internally. One detail was worth its weight in gold to me: almost every BSH machine has an internal data bus, called the D-Bus, that the individual modules use to talk to each other – the power module, the display, the sensors, and on newer devices also the WiFi module for Home Connect.

The bus is proprietary, but by now pretty well understood. On my machine it runs at around 13.5 volts and 9600 baud over two simple wires. So the plan was equally simple: tap in with a small microcontroller and just listen. Nothing to invent, nothing to rewire – just something to learn to listen to. Whatever the machine says internally, it’s already sending out anyway.

The moment that cost €315

So much for the theory. In practice, I had my adapter board (more on that below) in hand and, of course, wanted to get started right away. The obvious spot seemed to be up in the door, right behind the display – according to voices online, the bus should be there. So I plugged it in. And: nothing. No data, dead end.

To get to the bottom of it, I wanted to measure whether the bus even reaches up there. Out came the multimeter, probes onto the pins, which sit really close together – and in exactly that moment a probe slipped and briefly shorted two contacts.

The bill came instantly: first the fuse blew, then nothing happened at all when I switched the machine back on. A couple of lights still blinked defiantly, but the rest of the machine was dead. The central power module – basically the heart of the device – was gone, and the front module with buttons, LEDs, and time display right along with it.

The machine’s central power module – the black scorch mark on the left edge is the short circuit that cost me €315.

Nothing for it: gritting my teeth, I ordered replacement parts. Power and front module together, €315. On top of that, half the machine had to come apart just to reach the modules at all – all done myself, with what felt like half of YouTube’s repair community for backup. Between “board arrives in January” and “machine runs again in March,” quite a bit of time passed, during which we went back to washing dishes by hand. My family’s enthusiasm was, let’s say, limited.

The lesson, and I mean this seriously: never poke around with pointed probe tips inside tight connectors while there’s voltage on them. That one second cost me not just money, but a lot of nerves too.

Back to square one – this time with respect

After the repair I gave it another go, now with a lot more caution. The key insight: the board doesn’t belong up at the display, but down at the power module. According to other people’s experience reports on GitHub, it should have worked up top too – I never could fully clarify what went wrong in my case. After the expensive lesson, though, I didn’t want to take any more risks and stuck to what had worked for most people.

Down at the power module the mounting is fiddlier, but there are two dedicated pins meant for a service technician to read out. Clamped on there – and, sure enough, on the very first try: clean data, stable power, everything running exactly as it should.

The hardware: a €20 board instead of a €300 module

The centerpiece is a small adapter board that brings the bus level from 13.5 volts down to something a microcontroller can handle. Mine carries an ESP32-C6 running ESPHome – the open-source firmware that turns microcontrollers like this into full Home Assistant devices without much programming knowledge.

The board itself comes from an open-source project on GitHub. I got mine fully assembled through a group order for just under €20, connectors included – the full PCB layout is published, so anyone can have one built or make it themselves. There’s even a 3D-printable case with press-fit magnets in the repo, so the whole thing sticks neatly to the machine.

The complete adapter board: an ESP32-C6 plus a level shifter for the 13.5-volt bus – for just under €20 through a group order.

From a jumble of bytes to meaning – with logs and AI

Now I had a data stream. At first, though, that’s just a jumble of bytes: how do you know which packet means “door open” and which one means “47 minutes left”? Luckily, I didn’t have to start from scratch – there’s already groundwork out there, ready-made ESPHome components that log the bus traffic in general. My job was to translate all of that onto my specific machine.

I ran targeted wash cycles – for example the 40-degree automatic program with SpeedPerfect – and recorded the complete ESPHome log for each run. I then handed those logs to an AI, with clear context: “This was a 40-degree automatic wash cycle with SpeedPerfect – analyze the communication and note which patterns correspond to which state.” Repeated for many different runs: other programs, other options, door open, door closed. Bit by bit, raw bytes turned into an ESPHome configuration tailored to my machine – including documentation of everything found.

It now runs so reliably that I’ve officially published it:

👉 My ESPHome config + docs on GitHub

If you have exactly the same machine (Siemens SX66T096EU), you can take the configuration over directly. For a different BSH model, the patterns are generally similar but, depending on the device generation, not always identical. My config still works as a starting point – combined with exactly this logging-plus-AI workflow to adapt it to your own device.

The payoff: the dashboard

And then the moment that made all the effort worth it: my Home Assistant dashboard shows, while the machine is running, the current program, the status, whether the door is open or closed – and above all the exact remaining time. Not an estimate, but exactly the signal shown on the machine’s own display. It’s the same communication my board is listening in on, after all.

Every sensor straight from the D-Bus: program, remaining time, door, salt, rinse aid – live in Home Assistant, with no Home Connect involved.

I switched my “empty the dishwasher” notification (from an earlier video) straight over to the bus. That makes it better in two ways: it now detects the end of the cycle precisely instead of with a time delay – and it cleans itself up. As soon as the door opens, Home Assistant knows someone’s emptying the machine, and the reminder disappears on its own.

And because the machine also reports over the bus when salt or rinse aid is running low, I show that as a small hint right on the dashboard – instead of only noticing the next time I urgently need it.

Old beats new

I used to detect the end of the cycle via a switchable socket with power monitoring – a Shelly measuring power draw – and infer from the wattage curve: still running, or done. That works, but it’s always a bit of interpretation. The route via the bus gives me the actual status instead: running, not running, which program, how much time is left, even error messages. Considerably more precise – and, as a smart-home nerd, honestly a lot more satisfying too.

Which brings things full circle to the title: a 15-year-old machine with neither an app nor a cloud ends up giving me more, and more reliable, data than plenty of brand-new devices with Home Connect – all while staying 100% in the house. No account to set up, no cloud to rely on, no dependency on some manufacturer’s server.

One thing matters to me here: right now I’m only reading with the board – I’m deliberately not controlling the machine with it. Whether and how the bus can safely be used for sending too is being discussed in the community; as long as that isn’t cleanly figured out, I’m sticking to just listening in. For everything shown here, that’s completely enough.

Update 23 Sep 2026 – Practical tip: start the dishwasher on solar surplus using the delay timer

The board only listening in doesn’t mean I can’t influence the machine at all. The trick: I don’t control it over the bus, but the old-fashioned way – via the power supply, using the Shelly smart plug that still sits in front of the machine anyway. The board just supplies the knowledge of when the right moment to cut power is.

Operation stays entirely at the machine: if I set a delay timer of exactly 1 hour, Home Assistant reads that as “please wash with solar power”. Why exactly 1 hour? It’s quick to set on the machine – and I practically never use it as a genuine desired start time. Longer delays like 3 or 6 hours, on the other hand, I mean seriously; they should apply, so they run exactly as set. No app, no extra button – and anyone who doesn’t know about the automation just uses the machine as usual.

What I learned: let it start first, then cut the power

My first approach was the obvious one: cut the power just before the delay runs out and switch it back on when there’s PV surplus. That backfired. If you cut power during the delay, the machine doesn’t resume the delay when power returns – it resets it to a flat 30 minutes. Measured on two days in a row, even though 7 and 5 minutes were left when power was cut. That’s a reset, not a resume.

The counter-test showed the right way: let the delay run out normally, the program starts, and only 60 seconds later does the Shelly switch off. In that first minute the machine draws only about 20 watts, so it isn’t heating yet. When I switched it back on a good two hours later, the program continued immediately – the remaining time counted down from the very first minute. So a program that has already started resumes without any delay.

How the flow works

1-hour delay detected: the delay sensor from the bus jumps to 0.95–1.0 h → a helper spulmaschine_wartet_auf_pv is switched on. The jump upwards matters: a 3-hour delay counting down through 1.0 doesn’t trigger it.
Program started: the bus status has reported “running” for 60 s → Shelly off, push notification to my phone.
Sun’s out: PV surplus above 2000 W for 5 minutes → Shelly on, the program continues. At 4 pm at the latest it starts even without surplus, so there are clean dishes by evening.
Switched on by hand: if someone switches the Shelly on themselves, the postponement is cancelled – otherwise the automation would switch a manual start off again 60 s later (which is exactly what happened to me).

The core is the switch-off trigger on the bus status instead of the remaining delay time:

1
2
3
4
5
6
7


triggers:
 - trigger: state
 entity_id: binary_sensor.geschirrspuler_status
 to: "on"
 for:
 seconds: 60
 id: programm_gestartet

I calculate the PV surplus as a template sensor: inverter output minus house consumption minus wallbox – i.e. what would otherwise go to the grid or the battery. Threshold and latest start time are adjustable as helpers on the dashboard.

Does this work without the bus module? In principle yes, since the control runs purely through the smart plug. Without the bus, though, you lose the delay timer as your “control knob” and the exact program start. You can detect the start via power measurement instead, as described in my older dishwasher article – just with a bit more fuzziness. And most importantly: test first with your own machine whether it really resumes after a power interruption. Not every machine does, and the behaviour during the delay surprised even me.

Conclusion

It’s worth keeping old devices alive and making them smart instead of throwing them away. But let’s be honest, too: this path is not for a relaxed Saturday afternoon. You open up a device, work on electronics, and – as my €315 bill shows – you can break something. If you’re up for it: my complete config and docs are on GitHub (linked above), so you don’t have to start from zero.

And if this is all a bit too deep into the machine for you, but you’d still like to know when your dishwasher is done: check out my older video, where I solved exactly that without opening anything up – using nothing but a smart plug.

👉 Making any dishwasher smart – without cloud or rewiring

OBI Energy Tracker – For Beginners AND Home Assistant Pros

Thu, 23 Jul 2026 00:00:00 +0000

OBI launched a small electricity-meter reader at under €15 – and I’d argue it’s a small sensation. At that price there simply hasn’t been anything comparable, neither for beginners nor for advanced users. In this article I’ll show you two things: whether the OBI Energy Tracker is worth it for beginners and what the app can really do – and how to get the data into Home Assistant, with the OBI cloud, but also completely without the OBI cloud and app.

How I even got hold of the device: a friend forwarded me the heyOBI newsletter about the Energy Tracker and asked if I wanted to take a look. I thought it sounded interesting, and he put me in touch with someone at OBI – that’s how I ended up with my test unit.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What has changed since publication

This article is no longer quite the one that went live in July. Two things have changed, and more than a hundred comments brought in real-world numbers that aren’t in the video yet. I’m adding them here.

The price went up. The €15 were a launch offer. Right after the video went live, OBI raised it to the regular €29.99 – several of you pointed that out. Compared to a Tibber Pulse (around €130) that’s still a fair price, but it’s no longer the bargain it was.
Multiple sensors on one bridge now work. When the video came out this was only announced. Today the OBI FAQ states it plainly: with one account and one bridge you can run several sensors and track several electricity meters at the same time.
The official smart home integration is still missing. The FAQ still lists it as “firmly planned” – with no date.

The problem: smart meters in Germany

Smart meters and Germany – that’s an absolute disaster. Only about 5% of all meters in this country are so far a real smart meter, even though it would have solid advantages for both sides.

Most of us instead have a simple digital meter – in technical terms a modern metering device. An important distinction, because it often gets mixed up: a real intelligent metering system, i.e. the actual smart meter, is that modern metering device plus a gateway that sends the data to the grid operator on its own. That gateway is exactly what most people are missing – they only have the optical interface on the front to read the data out locally. And yet the question nags at anyone with a smart home: where does all the energy actually go?

What is the OBI Energy Tracker?

The device consists of two parts:

a sensor that is magnetically placed on the optical interface of your meter, and
a bridge that receives the data via radio (868 MHz) and passes it on to your WLAN.

The regular retail price is €29.99. At launch the device sold for around €15 – that introductory offer has since expired.

👉 OBI Energy Tracker at OBI (paid link)

Range: what gets through concrete?

By far the most common question in the comments: does the radio link reach from the meter in the basement up to the flat? That’s exactly what the two-part design is for. At the meter, the sensor needs neither a socket nor WLAN – only the bridge needs WLAN, and it can sit anywhere in between where both work.

OBI gives concrete numbers in its FAQ: in tests across various households, up to 6 floors were bridged between bridge and sensor, while “unusually thick reinforced concrete ceilings” cut that down to 2 to 3 floors.

The reports from the comments cover both ends of that range. @tudymsydym gets three floors through 1970s concrete down into the basement, where the meter sits in what is effectively a Faraday cage – with water meters transmitting in the same 868 MHz band all around it. For @m2kurim, on the other hand, nothing arrived from the fourth floor down to the basement; he solved it with an external magnetic-mount antenna on the sensor. If you run the open firmware, you also get the spreading factor as a lever: SF9 instead of the default SF7 noticeably extends range and penetrates walls better, at the cost of longer transmissions and therefore battery life.

Battery and power consumption

According to the FAQ, the sensor runs up to two years on two AA batteries; if you’d rather not swap them, you can power it over USB-C instead. For the bridge, the manual lists a “max. power” of 3.5 W – and someone in the comments rightly took issue with that, since extrapolated it would mean around €10 of electricity a year just for watching your consumption. So I measured it for over an hour: the average draw is about 0.5 W, and the 3.5 W are the peak during active radio transmission. That works out to just under 4.4 kWh a year, so more like €1.50 to €2.

Why it’s interesting

What was there comparable so far? The best-known candidate is the Tibber Pulse – but it costs around €130 for non-Tibber customers and is only usable in a limited way without an active Tibber electricity plan. Or the classic DIY route: an infrared reading head with USB on the meter, plus a Raspberry Pi and a rather crude console tool (Volkszähler / vzlogger). It works – but it’s not for the masses.

For €15, a beginner gets a finished app, while the advanced user gets a device that can even be pulled completely locally into the smart home (more on that below). A Shelly Pro 3EM can do more, but needs an electrician and DIN-rail space. The OBI is the simple, cheap way in – without touching any wiring.

Setup and the OBI app

The first curiosity: the feature is tucked into the completely normal OBI app, which at first feels like a shopping app. Only under Profile does the Energy Tracker show up as its own item. Unusual – but it works, and pairing the bridge and sensor is straightforward; every step is explained in the app.

Unlocking the meter (PIN from the metering point operator)

One point where many people get stuck: many digital meters only release the optical interface once you unlock them with a PIN. You get it from your metering point operator – you even have a legal right to it, but you have to request it once (many offer a contact form for this).

A tour of the app

The overview immediately shows the status of bridge and sensor. The consumption analysis is really well done for beginners:

at the top the absolute meter reading, separated into consumption and feed-in,
a daily overview as a bar,
an analysis view with day/week/month and the trend as a curve,
and – for those who don’t need it that precise – aggregated four-hour blocks (morning/afternoon/evening).

CSV export

The data can be downloaded as a CSV and analysed further in a spreadsheet. The values are provided in five-minute intervals. In my export you can nicely see the solar bell curve of my PV system (over 5 kW of feed-in around noon, with dips from passing clouds) and the big load blocks when the EV charges.

Standby analysis – handy, but with a caveat

I find the standby analysis especially interesting: on a completed day the app shows the standby consumption – not just in watts, but also as a share of daily consumption. Very vivid for getting a feel for your own base load.

An important caveat from an “…but secure” perspective: the sensor measures at the grid connection point – it only sees what flows between you and the grid, not what happens behind the meter inside the house. If, like me, you have a PV system with a battery, the battery covers the base load at night and almost nothing shows up at the grid. So the standby figure is mainly meaningful for households without a battery. If you have a battery and want a clean reading, it’s best to disable it for a day.

Firmware update

At the start a firmware update was pending – it ran in the background and was simply done after a few minutes. Nothing a beginner stumbles over.

Interim verdict for beginners

For beginners the device is absolutely solid: cheap, simple, and the app does its job.

Credit where it’s due: the Data Act page

Despite all the criticism of cloud solutions, one thing I find genuinely great: OBI has its own Data Act page. It states completely transparently what the device does and how it communicates – encrypted via MQTT in JSON, meter readings every five minutes, roughly 19 MB per month in total. Even the exact values that are read out (consumption, feed-in, current power) are listed, and only the technically necessary data is stored on the device itself. This openness is a requirement under the EU Data Act – but very few manufacturers implement it this cleanly. A big compliment for that.

In Home Assistant: the easy way via the cloud (HACS)

Many of you run Home Assistant as your smart home hub and want the values right there. For that, there’s an unofficial integration in the Community Store (HACS): install it, enter your heyOBI credentials – and your meter readings show up as sensors in Home Assistant.

➡️ hacs-obienergytracker-integration (GitHub)

The catch: this integration doesn’t get the data from the device, but from the OBI cloud. It logs in with your heyOBI account and queries OBI’s server. So without the cloud nothing works, and if OBI changes the interface, it breaks.

Completely local – without the OBI cloud

For anyone who wants to be truly independent, there’s another project: OBI Energy Tracker Local Cloud by Aaron Christophel (atc1441). The community has fully reverse-engineered the device. With it, you can redirect the bridge so that it no longer sends its data to OBI’s servers (on AWS), but directly to a server at your home – and if you want, you can even flash your own open-source firmware onto the device.

Roughly sketched: the meter provides its data optically to the sensor, which transmits it over 868 MHz to the bridge, and the bridge normally opens an encrypted MQTT connection to the cloud. Because an openly documented AWS IoT protocol is used here, you can point the bridge at your own local server – for example next to Home Assistant on the same Raspberry Pi. Optionally, an open-source firmware replaces the OBI software entirely, flashed via the normal update mechanism, without opening the case. The result: the tracker runs completely offline, in real time, directly in Home Assistant.

Rebuilding this step by step would go beyond this article. The detailed guide is now its own video: OBI Energy Tracker locally: OpenOBI without the cloud – from redirecting the cloud to proving that really not a single byte leaves your network.

What OBI is planning next

Good news to finish, especially for those who don’t want to tinker themselves: according to the OBI FAQ, an official integration into smart home systems (Home Assistant, OpenHAB, FHEM) is “firmly planned” – in OBI’s own words, “our heart beats for open source”. The point about multiple sensors on one bridge, previously announced there, has meanwhile been delivered. In the heyOBI newsletter, OBI additionally announces a live mode with per-second values and a consumption comparison with other households. So a lot of what’s still community tinkering today may soon arrive officially – and then this little device gets even more interesting.

Conclusion

Even at its now regular €30, the OBI Energy Tracker is a surprisingly good way to make your own power consumption visible – with a clean app and exemplary data transparency. The cloud requirement and the still-missing official HA integration are the weak spots. For tinkerers, though, the ability to run the device completely locally is exactly what tips the scales.

👉 Buy the OBI Energy Tracker at OBI (paid link)

3,500 km EV Road Trip: Charging with a Portable Wallbox

Thu, 16 Jul 2026 00:00:00 +0000

Four weeks, 3,500 kilometres, a fully electric car – from Germany through Austria and Italy all the way to Croatia and back. The big question upfront: is this relaxing, or is charging on holiday pure stress? My joker in the luggage was a portable wallbox, the go-e Charger Gemini flex. Here’s what I learned about charging from strangers’ sockets along the way – including the moments when things didn’t go smoothly.

Transparency: The go-e Charger Gemini flex was provided to me by go-e free of charge as a permanent loan for this test. (Ad)

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

How this came about

A bit of backstory, because transparency matters to me: go-e didn’t come to me – I reached out to them. I’d thought the go-e Charger was genuinely great long before this. My parents-in-law have been using one for ages, though in their case the hardwired version on the wall. When the road trip came up, I figured it was the perfect match: test the portable version in real travel life for a whole month and show it here on the channel. Hard to beat that.

Which is why I was all the more pleased that go-e was completely open to supporting me – and my still fairly small channel – with the wallbox. That’s also exactly why this video isn’t a paid-for puff piece but my honest travel report: everything that worked, and the moments when it didn’t.

What actually matters: the cost

At a fast charger you quickly pay around €0.80 per kilowatt-hour on the road. At a private socket in a holiday flat, it was often just around €0.10 at night here in Croatia – and in some places the electricity was even free. EVs simply aren’t the norm there yet, and hosts are correspondingly relaxed about it.

I kept a log over the four weeks: all told, I saved over €280 compared to what fast charging would have cost. Over an entire holiday, that’s a real difference.

Charging from an unknown Schuko socket: how many amps are safe?

The most common case on the road is the ordinary household socket – the Schuko. The immediate question is how much current you can reasonably draw from it.

go-e recommends 6 amps for unknown sockets. That’s the safe bet – but on my Cupra Tavascan (77 kWh) it means roughly 33 hours from 20 to 80 percent. The full 16 amps you should never draw continuously from a normal Schuko: it isn’t built for that and can overheat over time.

I wanted to know for sure and had my thermal camera with me:

First flat, overnight at 10 A: 6 A brought the socket to about 25 °C, 10 A to around 30–35 °C – both perfectly fine.
Second flat, even at 12 A – but there was a dedicated Schuko with its own fuse and RCD, mounted in the garage specifically for the car.

Rule of thumb without a thermal camera: if you touch the Schuko plug after an hour and it’s hot, something is wrong – dial the charging power right back.

I show what Schuko charging looks like in thermal view as one of five use cases in the thermal camera video.

More than Schuko: the adapter set

Schuko isn’t everything. The go-e Charger comes with an adapter set of three adapters, and that’s what makes the box truly flexible:

Schuko adapter for the normal household socket.
Blue camping plug (blue CEE) – familiar from campsites, found almost everywhere there, and rated to deliver 16 A continuously.
Red CEE adapter for industrial power sockets. Important: not every red socket is the same – some are for 11 kW, some for 22 kW, and they differ in size. That’s what the red-to-red adapter in the set is for.

Control via the app – local, no cloud

The box is controlled through the go-e app. The nice part: it opens its own Wi-Fi hotspot – you need no internet and no cloud, everything runs locally.

One pitfall cost me some nerves early on: your phone has to be on the box’s Wi-Fi, otherwise the app can’t find the box. If you’re also in range of the holiday flat’s Wi-Fi with internet, the phone happily prefers that one – and the box is “gone”. When in doubt, quickly check which network your phone is actually on.

A word on the charging log, in case you want to settle up with your host: the box does keep a log, but on the road it has no network and therefore no date or time. For our billing we simply used the car’s charging log instead.

Safety & practical details

LEDs can be switched off – handy when charging in a publicly accessible car park where you don’t want the box drawing attention at night.
Cable locking at the box – so a spontaneous theft isn’t easy.
Built-in RFID reader: you can set the box to charge only after authorisation with the included chip.
Unplugging order: always pull the Schuko plug only once charging has stopped. The Type 2 plug at the car is locked and built to be disconnected under load – the Schuko isn’t. Pull it under load and you get small arcs that can destroy the socket over time.

The glitch in Split

Of all places, at the dedicated socket in Split the charge stopped abruptly one night – the go-e app said “phase not available”. First thought: is the box broken? It wasn’t. At the same time there was a heavy thunderstorm and a brief power cut. I only noticed because the car automatically pushed a notification to my phone. Restarted the charge, everything ran normally again.

The lesson: if a charge cuts out, don’t immediately blame the box – often the power source is the culprit.

Too bulky for travel? The dual benefit

Yes, the box is bigger than a plain charging cable. But the point is: you only need one wallbox. At home, have an electrician fit a blue or red CEE socket and run the box on its included wall bracket as a fixed installation. When you head off on holiday, unplug it and take it along. No second purchase.

Verdict

Does a portable wallbox pay off for travellers? After 3,500 kilometres, a clear yes for me. I was independent of public charging infrastructure at every stop, charged far more cheaply and could top the car up overnight – almost like at home. There are a few things to keep in mind, but comfort and savings combined won me over.

If you want to take a closer look at the go-e Charger Gemini flex, you’ll find it on Amazon in the 11 kW version* (the one I used) and the 22 kW version, plus the matching adapter set.

* Links marked with an asterisk are affiliate links. As a partner I earn from qualifying purchases – at no extra cost to you.

Plug In a USB Stick, Own the Device – the FatFs Flaw

Thu, 09 Jul 2026 00:00:00 +0200

It was one of those moments where I stop mid-scroll through the news feed. A headline, half technical, half sensational – and a gut feeling that instantly says: Oh no. I’m going to have to make a video about this again.

The story: security researchers had found seven flaws in a piece of software most people have never heard of. The name sounded harmless – FatFs. But the deeper I read, the clearer it became: this isn’t some niche topic for firmware nerds. This tiny piece of code sits inside millions of devices. Very likely in your home, too. And the way these flaws were found honestly gave me goosebumps.

So: grabbed a tea, opened the research doc, set up the camera. Here’s the whole story.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The nightmare in one sentence

Imagine someone plugs an ordinary USB stick into your device. They don’t type anything, don’t open a file, don’t crack a password or bypass a firewall. They just plug it in. And in that very moment, the device no longer belongs to you – it belongs to them.

That’s exactly what the most dangerous of these flaws makes possible. No sophisticated network attack, no stolen password – a rigged storage medium is enough. And the crazy part: the code that makes this possible is probably running in a device in your home right now.

What even is FatFs?

FatFs is a free, platform-independent software module written in C. Its only job: to teach a device how to read and write FAT- and exFAT-formatted USB sticks and SD cards.

Sounds trivial. But it’s exactly what you need when a device doesn’t have a full operating system like your laptop does. Your security camera, your ESP32 hobby project, an industrial controller, a drone – none of these have a Windows or Linux kernel to read the USB stick for them. They need a small, lean driver that handles exactly that. And very often that driver is FatFs.

Because FatFs is so small, so free, and so reliable, it’s baked into the base kits (SDKs) that countless devices build upon – not just hobby projects, but finished products sold in the millions worldwide. A tiny building block with a gigantic reach.

The sore spot: maintained by a single person

And here’s the first part that gives you pause. FatFs is essentially maintained by one single person – the Japanese developer known by the handle “ChaN”. No security team. No security mailing list. No vulnerability reporting channel. No CVE history.

One person, as a volunteer, looks after code that runs in millions of devices. That’s not a criticism of that person – on the contrary, it’s an admirable contribution to the common good. But it’s the core of the problem we’re about to hit. (If you want the pattern behind this: it’s exactly the kind of “lonely dependency in the foundation” that xkcd nailed in a legendary 2020 comic.)

The most dangerous flaw: CVE-2026-6682

Each of these vulnerabilities gets a unique ID and a severity score – a number between 0 and 10. The worst of the seven is CVE-2026-6682, rated “high” with a CVSS score of 7.6.

What happens technically? Here it is, without the jargon:

When your device reads a memory card, it blindly trusts the size values stored on the medium for each file. It does its math with those numbers to find its way around the card – which file sits where, how long it is, where to read.

Now the attacker writes completely absurd numbers onto a manipulated SD card. The device does its math with them anyway, because it trusts the card. And in doing so, the calculation overflows – a so-called integer overflow. A bit like an old odometer rolling over from 9,999 back to 0. Except here it’s not the counter that breaks – the device suddenly starts writing to a completely wrong location in memory.

And that’s exactly what an attacker can exploit to inject their own malicious code. The researchers at runZero put it bluntly:

Why does this work so reliably? Because small IoT devices almost never have the protections your PC has long had: no random shuffling of memory addresses (ASLR), often no real memory protection. What would fail at several hurdles on a modern PC sails right through on a bare microcontroller.

Not just one flaw – seven

CVE-2026-6682 is the most spectacular, but it doesn’t come alone. There are seven vulnerabilities in total (CVE-2026-6682 through -6688), and three of them have code-execution potential:

CVE	Short description	Impact
6682 ⭐	Integer overflow on FAT32 mount	Code execution (RCE), CVSS 7.6
6683	Division by zero (exFAT)	Crash / denial of service
6684	Infinite loop on partition scan	Device hangs on mount
6685	Integer underflow in cache	Silent data corruption
6686	Uninitialized memory after seek	Old, deleted data readable
6687	Stack overflow via exFAT label	Code execution (esp. STM32)
6688	Overflow via long filename	Code execution

The common denominator across all seven: FatFs blindly trusts the metadata on the storage medium – file size, label length, partition count – and does its math with it without ever checking whether the values are even plausible.

How big is the blast radius?

Now the key question: does this even affect me?

Among the affected projects is Espressif’s ESP-IDF – the development foundation for the famous ESP32 chips. And if you know my channel, you know these chips are everywhere. In ESPHome devices, in Shellys, in countless hobby projects – but also in masses of commercial off-the-shelf products. I’ve already made several videos about ESP security flaws, and it just doesn’t stop.

The researchers verified 17 concrete projects that contain vulnerable FatFs code:

espressif/esp-idf (ESP32) – the basis of ESPHome, Tasmota, Shelly & co.
STM32Cube – in countless industrial and consumer devices
Zephyr RTOS and MicroPython – growing IoT platforms
ArduPilot – flight control for drones
Keystone3 – a hardware crypto wallet (this is about real money)
Samsung TizenRT, RT-Thread, Mbed, RIOT, NodeMCU and more

Explicitly named as an attack target: security cameras with an SD card slot. Exactly the kind of camera many of us have hanging by the front door, in the garage, or in the stairwell.

And here’s the truly insidious part: you can’t even easily check whether your specific device is affected. Because which manufacturer writes on the box which filesystem driver they’ve buried deep in their firmware? Nobody does. So the honest rule of thumb is: if you own an embedded device with an SD card or USB slot, assume in case of doubt that it could be affected.

The real twist: an AI found the flaws

Now comes the part that made me want to do this video in the first place. Because how these flaws were found is almost more interesting than the flaws themselves.

These same researchers had already looked at FatFs once before – back in 2017. Back then they combed through the code by hand with human experts and fuzzed it for days. The result: a few minor bugs. Nothing earth-shattering.

Now, in early 2026 – almost ten years later – they look at the same code again. But this time with a new helper: GitHub Copilot, an AI coding assistant of the kind developers now use by the millions every day. No specialized attack framework, no elaborate fuzzing pipeline. The plain default mode in VS Code, with a few simple prompts.

And suddenly out tumbled flaws that nobody had seen in 2017 – even though the vulnerable code already existed back then. An off-the-shelf AI with a few simple prompts uncovered it within days.

The researchers’ sentence that gave me goosebumps:

And that is the real story. Here it’s the good guys who used the tool – and who reported their findings responsibly. But we have to assume that just as many others are doing the exact same thing right now. And they most certainly don’t publish their findings.

The barrier to finding flaws in the “long tail” of old, long-overlooked code has just collapsed. For defenders and attackers alike.

The second shock: there’s no patch

“Alright,” you might think, “then an update will come and it’s sorted.” And that’s exactly where the next problem lies.

Remember the one-man project? The researchers contacted the maintainer back in March 2026, several times since. They even brought in JPCERT/CC – Japan’s coordination center for security vulnerabilities. The response to date: radio silence.

That means there’s no central patch to simply roll out. Every single project that builds on FatFs – ESP-IDF, Zephyr, STM32Cube, MicroPython and all the rest – now has to find the flaws itself, fix them itself, and then ship the updates to its own devices. And the manufacturers of those devices in turn have to follow suit.

The researchers therefore estimate the window until widespread remediation in years, not days or weeks.

Staying honest: the “physical access” fallacy

And now let’s take a breath. Because here comes the part many sensational headlines leave out – and where most people make a thinking error.

This attack requires physical access. The manipulated card or stick actually has to be plugged into the device. This is explicitly not the “a hacker breaks into your camera from the internet tonight” scenario. If a device sits safely in your home and no stranger can reach it, such a jailbreak isn’t a catastrophe.

There’s even a fair objection I keep reading in the comments on other reports: for “locked-down” devices you own yourself, being able to jailbreak them via USB is arguably more of a feature than a threat. There’s something to that.

But – and here’s the thinking error – there very much are situations where this hits you hard:

Used devices. You buy a camera or hobby device secondhand and don’t know what’s on the included memory card.
Cameras in accessible spots. Doorbell, garage, stairwell, office building – anywhere someone could quickly swap an SD card.
The unattended moment. A cleaner, a technician, a visitor. A few seconds of physical access is enough. In security this is called “evil maid”.
The supply chain. Rigged storage media that arrive already manipulated.

So this isn’t an apocalyptic scenario. It’s about realistically assessing your own threat model – instead of panicking or reflexively dismissing the whole thing.

Your smart home survival tips

You can barely verify whether a device is affected. But you’re not powerless:

Install updates. I say it in every other video – but that’s exactly what updates are for. As soon as Espressif, ESPHome or your camera manufacturer follows up: install, don’t dismiss.
Think about which devices strangers can reach. Not every device is equally exposed. The camera on the outside wall is a different risk than the sensor in your living room.
Always reset and reflash used devices before letting them into your network. You never know what the previous owner left on them.

The real lesson

In the end, this one flaw isn’t the big story. FatFs will get fixed, sooner or later. The real lesson is a different one:

AI has driven the cost of finding bugs like these to near zero. Code that flew under the radar for ten years is now uncovered in days – by off-the-shelf tools anyone can use. That’s good news when the good guys are faster. And unsettling news when they’re not.

Over the coming years we’ll see a lot more reports like this. That’s exactly why this video mattered so much to me.

Sources & further reading

runZero – original report: Seven FatFs bugs, one very large blast radius
runZero – research repo with PoC & details: vulns-2026-fatfs-chance
Risky Business: FatFs bugs enable physical access attacks on a load of devices
FatFs – official project page: elm-chan.org/fsw/ff

More on the blog

ESPHome security flaw: critical CVE hits all ESP32 devices

Do you find AI hunting for security flaws more reassuring or more unsettling? Let me know in the comments – I’m curious about your take.

From EASY to NERD: 3 Smart Home Devices Nobody Knows

Thu, 25 Jun 2026 00:00:00 +0200

“You always go just a little bit further than everyone else.”

A friend said that to me recently. We were talking about smart home setups — who has what, who’s planning what — and at some point he just dropped that sentence. Not as criticism. More like an observation.

And he’s right. I don’t just buy something. I google whether I could build it myself first. And if I end up buying it anyway, I check whether I can hack it.

The video this article accompanies is a kind of inventory of that tendency. Three devices I actually use every day. One I had shipped to me. One I took apart eight years ago and never fully closed back up. And one I soldered myself.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The countertop dishwasher I didn’t know existed

The Blitzhome BH-CDW1 was sent to me by the manufacturer. And that’s honestly exactly why I know about it — because I would never have searched for it myself. I didn’t even know this product category existed.

A dishwasher the size of a large microwave. No fixed water connection required. Fits dishes for two to three people. And in the smart version — the BH-CDW1, about ten euros more than the base model — you also get Wi-Fi, an app, and a remaining time display.

I live alone. I didn’t have a dishwasher before because fitting one in my rented flat felt like too much hassle. This thing changed my mind. It’s quiet, fast, and I put it on the kitchen counter. No plumber, no burst pipes, no stress.

Smart home? Sort of, yes. But the real point is different: it’s the only one of the three devices you can just go out and buy. Which is exactly why it comes first.

Available on Amazon:

Blitzhome BH-CDW (standard) (affiliate link)
Blitzhome BH-CDW1 (smart version with app) (affiliate link)

Disclosure: This device was provided to me free of charge by the manufacturer. The review reflects my own opinion.

The range hood I haven’t touched since 2017

Now it gets more personal.

I have a problem with my range hood. Not technical — human. I forget to turn it off. On low speed it’s so quiet it disappears from my awareness entirely. I cook, I eat, I walk to the living room — and the hood keeps running silently.

By 2017 I’d had enough. I’d just started working with ESP8266 modules. I thought: there has to be a way.

The hood is a Sombra model by Gutmann. A normal device, nothing special — except for one thing: the front panel with its buttons and LEDs communicates with the control unit via a completely standard network cable. RJ45 connector. Standard cable. I simply tapped my ESP8266 in between.

The chip listens to the lines via hardware interrupt — a matrix controller running at 1000 Hz. Every button press, every LED change. And it can simulate button presses itself. Without the hood ever noticing.

The first test was — let’s call it memorable. I had everything wired up, powered it on, and then a relay clicked. And nothing worked anymore. No lights, no response, the hood completely dead.

I went to the basement, pulled the fuse, waited a minute. Restarted. Everything came back — thank god, nothing was broken.

What had really worried me: the manufacturer Gutmann no longer exists. Bankrupt for years. No spare parts, no customer service. If I’d fried the control unit, the device would have been scrap. Irreplaceable.

Since then the hood has run for eight years without a single intervention. In Home Assistant I can see the light state, the fan speed from 0 to 4, schedule it with a timer — and I get a notification when the grease filter needs cleaning. I reset the filter reminder directly from HA.

This isn’t ESPHome. It’s a manual Arduino project, compiled in VS Code, because the timing is too critical for ESPHome. Not pretty. But stable.

The full build writeup from back then: DIY IoT module for the range hood

The plant sensor you can’t buy anywhere

I stumbled across the b-parasite project on GitHub completely by accident. No company behind it, no web shop, no support. Someone designed a PCB, published the files, and the community ran with it.

I knew immediately: I want this.

You order the bare PCB from the manufacturer of your choice. You solder it yourself — an ESP8266 and a CR2032 battery holder are the most expensive components. You end up at around ten euros per sensor. Commercial plant sensors start at €20, €30 — and do half as much.

The sensor sits in the soil and measures moisture. It broadcasts over Bluetooth Low Energy — not directly to Home Assistant, that would be too far — but to my Shellys, which act as BLE gateways. The Shellys forward the data. In HA I can see the current moisture level for every houseplant.

I soldered ten of them.

The most practical thing about it: when I’m on holiday and a plant is about to die, HA sends me a notification. I message my neighbour. She comes over. Not based on gut feeling, not based on a calendar — exactly when it’s needed.

EASY, DIY, NERD — and that extra bit further

Three devices. A countertop dishwasher off the shelf. A range hood that’s been hacked for eight years. Hand-soldered plant sensors.

What they have in common: nobody in my circle of friends has any of them. And all three solve problems that nothing off the shelf solves.

My friend is right. I always go a little bit further. But that’s exactly what keeps smart home interesting for me.

What’s your quirkiest smart home device? Self-built, discovered by accident, or just absurdly practical — write it in the comments.

Shelly Installation: 5 Mistakes Almost Everyone Makes

Thu, 18 Jun 2026 00:00:00 +0000

Shellys are small, affordable, and powerful. And yet the same mistakes come up again and again during installation – some just annoying, some genuinely dangerous. Here are the five I see most often.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Mistake 1: No Neutral Wire – Installed Anyway

Many older installations in Germany have no neutral wire in the switch box – normally the blue wire, sometimes grey in older setups. Instead, you only find the live and switch wires.

Some Shelly models offer a “No-Neutral” mode. Sounds tempting – and it works in many cases. The problem: in No-Neutral mode, a small residual current always flows through the load. Whether this causes flickering or simply doesn’t work at all depends on the LED driver. Shelly specifies minimum load values – many modern, highly efficient LEDs fall below them. The mistake isn’t No-Neutral itself, it’s installing without testing first.

What helps: First check whether a neutral wire is available in a cable duct or distribution board – it’s often there, just not routed to the switch box. If there really isn’t one: choose a Shelly model that explicitly supports No-Neutral, install it, test it – and only then put the switch cover on.

Dangerous edge case: Some people, lacking a neutral wire, reach for the green-yellow protective earth as a return path. This is life-threatening. The protective earth is not a neutral wire substitute – misusing it can put the housing of connected devices under voltage.

Mistake 2: Too Little Space – The Hot Box

Shellys are small. But not so small that they fit effortlessly into every flush-mount box – especially when there’s already a light switch and several cables in there.

The symptom: the box gets warm. That’s heat with nowhere to go because the Shelly is squeezed in. Shellys have a built-in temperature limit – when it gets too hot they shut off automatically. That sounds like a safety feature, but it’s a sign something is fundamentally wrong.

What helps: Check before installing whether the space is genuinely sufficient. Don’t squeeze, don’t bend. If in doubt, have a deeper box fitted. Also: in the Shelly settings there’s an Eco Mode (Web UI → Settings → WiFi → Eco Mode) that reduces Wi-Fi transmit power when idle, which also lowers self-heating. I enable it as a matter of course.

Mistake 3: Wrong Tools – Nicked Wires

Side cutters along the side of the cable – almost everyone does it. The outer sheath comes off, looks tidy. Until you look more closely: a nick in the wire insulation is almost inevitable this way. Sometimes just a small scratch. You can barely see it – but under load or over time, that’s exactly what can cause a short circuit or insulation failure.

What helps: Two tools solve this permanently:

Cable stripping tool (I use the Knipex ErgoStrip, also at OBI): One rotation around the cable and the outer sheath is cleanly separated – without touching the wires.
Self-adjusting wire stripper (Knipex PreciStrip, also at OBI): Detects the wire cross-section automatically, cuts only the insulation, no nicked copper.

Once you’ve tried them, you’ll never reach for side cutters again.

Mistake 4: Bad Connections

The right tools alone aren’t enough – there are three typical mistakes when making the actual connection:

Wrong Strip Length

Too short: the terminal barely grips the copper, contact resistance increases, the connection runs hot. Too long: bare copper protrudes beyond the terminal – short circuit risk to the neighbouring terminal.

The correct length is in the manual for your Shelly model – usually 6–7 mm.

Clamping Stranded Wire Directly

Anyone working with extensions or flexible cables is dealing with stranded wire. Clamping stranded wire directly into a screw terminal is a fire hazard: the individual strands bend, oxidise, and the connection deteriorates over time.

Tinning Stranded Wire – Sounds Good, Is Wrong

Tinning stranded wire before clamping it sounds like a good idea. It isn’t. Solder deforms under sustained clamping pressure – this is called cold creep. The connection that felt solid at installation will work loose over time. It’s not a question of whether, but when.

The Right Solution: Ferrules

The solution is the ferrule – a small metal sleeve you slide over the stripped stranded wire and crimp with a ferrule crimping tool. Once crimped, it behaves like solid wire in the terminal. The Knipex ferrule crimper* (also at OBI*) makes this quick and precise.

Mistake 5: Working Live

Before you do anything at a flush-mount box, there are five safety rules for working on 230-volt mains: isolate, secure against re-energisation, verify absence of voltage, cover adjacent live parts, obtain clearance.

Do you know them by heart? If not, that’s not a criticism – but it’s a clear signal: this work belongs in professional hands. Section 13 of the German Low Voltage Connection Regulation (NAV) states exactly that: work on 230-volt mains may generally only be carried out by registered qualified electricians. This video and this article help you understand the principles and prepare yourself as well as possible – but the actual work belongs with a professional.

All five rules with explanations, the right test equipment and the typical traps in the wall box are collected on a separate page: Working safely with mains voltage.

Want Shelly or Home Assistant Installed Professionally?

This section is a paid collaboration with Gerlach Smart Solutions.

Anyone who’d rather hand off the installation usually runs into two problems: most electricians don’t know Shelly and tend to recommend expensive proprietary systems instead. And even when someone does install Shelly, the service typically ends with the last screw – automations and setup are left to you. Because anyone who wants to use Shelly or Home Assistant professionally needs more than individual devices: a solution that fits the electrical installation, the building, and the desired functions – and is properly installed, configured, and commissioned afterwards.

Gerlach Smart Solutions does exactly that. Benjamin Gerlach is a master electrician and DEKRA-certified expert, specialised in open systems like Shelly and Home Assistant. The focus is on retrofitting existing buildings – roller shutters, lighting circuits, energy monitoring, PV surplus use – as well as well-thought-out smart home solutions in new builds. The service is a complete package: free initial assessment, selection of appropriate components, professional installation by qualified electricians – followed by setup, optimisation, remote maintenance, and programming of scenes, schedules, and automations. From planning to a finished, everyday-ready smart home, nationwide across Germany.

If you want to install yourself but aren’t yet sure about product selection, planning, or preparation: Gerlach also offers consultancy. And if you’re using your own electrician, you can request a complete planning document as a basis.

You remain in full control of your own system. No cloud lock-in, no dependency on the service provider for every small change.

👉 Request a free initial assessment

Use code SICHER25 to save €25 on a subsequent installation booking.

Summary

Five mistakes, all avoidable. Check the neutral wire situation beforehand. Verify that the space is sufficient. Use the right tools. Connect properly: observe the correct strip length, always use ferrules with stranded wire, never tin it. And never work at a flush-mount box without properly isolating the circuit first.

Have you made any of these mistakes yourself – or do you know other Shelly pitfalls? Let me know in the comments under the video.

* Affiliate links (Amazon & OBI/Awin). As a partner I earn from qualifying purchases. No additional cost to you.

Thermal Imaging in the Smart Home: 5 Use Cases

Thu, 11 Jun 2026 00:00:00 +0000

A thermal imaging camera sounds like professional gear for thermographers or energy consultants. But as a smart home enthusiast, I use one for all kinds of things: checking electrics, finding hotspots in devices, inspecting my solar array – and making problems visible that all my sensors in Home Assistant simply cannot detect.

Transparency: The Thermal Master P3 was provided to me free of charge by the manufacturer – with no conditions on the content. (Ad)

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What a thermal image actually shows

The color gradient from blue to red shows temperature differences – but relatively: the coldest spot in the image is always blue, the warmest always red, whether we’re talking 20 or 80 degrees. For context, the camera displays the warmest and coldest spot as absolute readings, plus the exact temperature at the center of the image.

One detail shows how sensitive it is: the imprint of my hand on the desk was still visible seconds later – from body heat alone.

The Thermal Master P3 offers a resolution of 512×384, a focus ring for close-up and distance shots, and a dual-image mode that overlays the thermal and the visual image.

Use case 1: Checking Shelly flush-mounted boxes

Behind one of my light switches sits a Shelly 1 Plus for the underfloor heating. From the outside everything looks normal – but the thermal image shows 25 degrees on the outside of the box, with an ambient temperature of 21 degrees. Inside it’s definitely more – otherwise nothing would be measurable outside.

It’s not dramatic – but Eco Mode makes the difference visible: it throttles the Wi-Fi chip during idle periods, and the outside temperature drops to 23 degrees. Less heat means less power consumption and, above all, slower aging of the electronics. I’ve personally repaired Shellys with failed capacitors before. What goes wrong during installation – from too little space in the box to the wrong tools – I cover in a separate article: 5 mistakes almost everyone makes when installing Shelly.

Use case 2: Exposing standby power hogs

In the thermal image: a box, clearly warmer than its surroundings. In the visual image: my Sonos Play One – 3.8 watts in standby, officially stated by Sonos.

For comparison: in 2010 the EU mandated that household devices may draw a maximum of 1 watt in standby. The Play One launched in 2013, but as an audio device with active network standby it falls under an exemption – a loophole Sonos is happy to use.

With five of them in my home, that means 20 watts around the clock: 175 kWh per year, roughly 50 euros – just for standby. I now deliberately disconnect them from the mains.

Use case 3: Comparing thermal design – Raspberry Pi vs. Zimaboard

On a Raspberry Pi 4 under load you immediately see chips and voltage regulators heating up in concentrated spots – the heat piles up at individual points. Small stick-on heat sinks barely make a measurable difference.

The Zimaboard 2 with its massive aluminum case shows the opposite: no sharp edges in the thermal gradient, no hotspots – the heat spreads evenly across the entire enclosure. The chip isn’t any cooler, but the energy is dissipated in a controlled way.

That’s the real value of the camera: you don’t just see whether something is hot – you see how a device handles heat.

Use case 4: Checking the solar array for hotspots

A neat effect: solar modules appear cooler than their surroundings in the thermal image – solar cells convert light into electricity rather than heat, and reflect part of the radiation.

What stands out are “blotches”: irregular heat patterns on individual modules. That’s a warning sign – it could be a cell defect or just dirt. In my case it was harmless (a sun reflection during filming), but the principle holds: otherwise your yield quietly drops without any visible reason from the outside.

A once-a-year scan of the array – a use case that pays off for every solar owner.

Use case 5: Charging an EV from an unknown Schuko socket

On my road trip to Croatia I charged my EV from a Schuko socket at a vacation rental – an unfamiliar electrical installation of unknown age and dimensioning. Schuko sockets are not designed for continuous full load at 16 amps.

My approach: start at the mobile wallbox’s minimum (6 A), check the thermal image, then step up to 10 A. Wallbox and charging cable visibly warm up – that’s just physics. A look straight into the socket (cable briefly unplugged): warm, but well within limits. Continuous charging at 10 A was no problem at this socket.

Without the camera I would have either charged far too cautiously or simply hoped for the best.

Conclusion

Heat is, in the end, nothing but wasted energy – and a thermal camera makes it visible before any sensor does. For smart home users with their own electrics, a home server, a solar array, or an EV, it’s a tool that pays off surprisingly often.

Deal (until June 28 only): The Thermal Master P3 is €45 off on Amazon* – discount code THERMALCM10. According to the manufacturer, the best price this year.

* Links marked with an asterisk are affiliate links. As a partner I earn from qualifying purchases – at no extra cost to you.

Smart Home Time Bombs: Cloud Dies, Device Dies

Thu, 04 Jun 2026 00:00:00 +0200

A video of mine that had barely attracted any attention for months suddenly jumped to over 16,000 views within a few days. I hadn’t changed anything. YouTube hadn’t pushed it. But on one specific day, someone in a corporate headquarters had pressed a button — and in doing so, switched off a piece of thousands of people’s smart homes.

Bose had shut down the cloud service for SoundTouch.

And people flooded my channel — angry, stunned, looking for answers.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

“I could just throw up”

The comments that poured in over the following days left a real impression on me. Not because they were so aggressive — but because they were so honest.

None of these people had fundamentally done anything wrong. They bought expensive brand-name products, took care of them, and used them every single day for years. And then someone in a corporate headquarters decided: this isn’t worth it anymore. We’re shutting down the servers.

I don’t own a Bose SoundTouch myself. I watched the whole thing from the outside — as someone who had already made a video about exactly this risk. But I know the feeling anyway. From people around me. Over and over again. A friend who wakes up in the morning and his smart plugs no longer respond. An acquaintance whose heating control suddenly goes offline because the manufacturer “discontinued the cloud subscription.”

People who bought in good faith. And who bear no responsibility for what happened.

That’s exactly why I made this video. Not to bash Bose. But because the pattern keeps repeating.

This is not an isolated incident. It’s a pattern.

Bose wasn’t the first. And won’t be the last.

Insteon, April 2022: Overnight, without any warning, all servers shut down. Around 100,000 users wake up one morning: nothing works anymore. No cloud, no app, no support. The CEO was unreachable.

Wink, May 2020: Users were suddenly given a choice — pay a monthly fee or accept shutdown. Less than a week’s notice. The packaging had explicitly stated: no subscription fees.

Belkin WeMo, January 2026: Announced in July 2025, shut down in January 2026. All devices affected, regardless of age. Only after public pressure was a partial refund offered.

The pattern is always the same: buy a device. Use it for years. One day an email arrives. Or maybe nothing at all. And suddenly it’s over.

In the video I show you how to spot these time bombs — before you buy, not after.

I’ve been sensitive to this issue for a long time. My entire smart home runs locally — no external server, no cloud dependency. Switching to Home Assistant was the moment I understood that I genuinely wanted to be in control of my smart home.

But honestly, I still have a blind spot: my Shark robot vacuum.

It runs on the Shark cloud. And I know exactly what that means. At some point an app update, a server shutdown, or a corporate acquisition could cause my Home Assistant integration to simply stop working. I know this. And I haven’t changed it yet.

That’s my deliberate compromise. And that’s the difference: you can use cloud devices. But you should know that you’re doing so.

Whether your devices are at risk — and how to find out quickly — is what I explain in the video.

What’s really at stake

The Bose story didn’t affect me because of the technology. And not because of the money.

It’s about trust.

The trust that a product will work tomorrow just as it does today. That I can tell a friend, three years from now, whose smart home setup I helped build: that still works. You’re in control of that.

That trust is the foundation of every smart home. And it’s more fragile than most people think.

In the video I show you four concrete questions to identify risky devices — and three steps you can take starting today to protect yourself.

The €5 IKEA Button's Secret Zigbee Mode – How to Use It

Wed, 20 May 2026 00:00:00 +0200

The packaging says Matter. The IKEA website says Matter. All the marketing: Matter.

And yet there’s Zigbee inside. Complete, functional, usable – and IKEA doesn’t say a word about it.

A button for five euros

In late 2025, IKEA added two new remotes to their lineup under the Bilresa name. The E2489 with two buttons – up and down – and the E2490 with a scroll wheel and an additional button. Both cost around five euros. Both run on two AAA batteries. And both say: Matter.

Matter over Thread, to be precise. Which means: without a Thread Border Router – like an Apple TV, a HomePod mini, or the ZBT-2 for Home Assistant – nothing works out of the box.

Or does it?

Zigbee and Thread share the same radio standard – IEEE 802.15.4 at 2.4 GHz. A single chip can do both; it’s just a matter of firmware. IKEA chose to market Thread externally. But for backward compatibility with older IKEA bulbs via Touchlink, the Zigbee stack in the chip is still fully present. And that’s exactly what we can use.

What this means – and why it’s worth it

For anyone already running a Zigbee network, this is pretty good news. Because the Bilresa costs a fraction of what comparable Zigbee buttons typically cost.

The Bilresa holds its own: two buttons, single click, double click and long press per button – that’s six different actions you can freely assign in Home Assistant. AAA batteries instead of CR2032. And of course: no IKEA account, no cloud, everything local.

The only thing you need is a Zigbee coordinator – which you most likely already have.

The honest warning first

I’ll say this before anyone ends up disappointed: Zigbee mode is not officially supported by IKEA. It exists as a side effect of Touchlink backward compatibility – not as an intentional feature.

What that means in practice: while the button is paired in your Zigbee network, it receives no firmware updates from IKEA. Those only come via the Matter/Thread path. That doesn’t happen by accident – and if you ever re-pair the button via Matter and install an update in the process, the Zigbee mode could disappear.

In Zigbee operation itself: no risk. And for five euros, that’s a reasonable trade-off.

Pairing: the button sequence IKEA doesn’t document

The pairing is the trickiest part of the whole thing. It’s not intuitive, and if you don’t know the steps, you won’t figure it out on your own.

In brief:

Factory Reset: Remove the cover, hold the pairing button for about 10 seconds until the LED pulses amber. Don’t let go too early.
Touchlink mode: Press the pairing button 4 times quickly in a row. The LED flashes amber rapidly.
Enable Permit Join in Zigbee2MQTT or ZHA.
Zigbee mode: Press the pairing button 8 times quickly in a row. The LEDs go completely dark – that’s correct. No visual confirmation.

Your coordinator will now find the button. In Zigbee2MQTT it appears as BILRESA remote control with buttons.

Speed matters. No long pauses between presses, otherwise the button won’t recognize the sequence. If it doesn’t work the first time: just start over. The video shows the entire process live, including the stumbling blocks I ran into myself.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Six actions, one decision

What arrives in Zigbee2MQTT after pairing is clean: the E2489 sends single click, double click and long press for each of the two buttons. Six different events you can freely link to automations in Home Assistant.

One small thing to know in advance: the button waits about one second before sending a single-click event – it needs to check whether a second click follows. That’s by design and can’t be changed. For turning lights on/off, that’s perfectly fine. For time-sensitive use cases like alarms, you should be aware of it.

For automations in Home Assistant, there are two approaches: with the experimental_event_entities setting enabled in Zigbee2MQTT, each button gets an action entity you can use to build automations with normal state selection. Alternatively – and without that setting – a direct MQTT topic trigger works just as well. Both approaches are explained in the video.

Zigbee or Matter – which is right for when?

If you’re wondering whether to go the official Matter route instead, here’s a direct comparison:

My take: if you already have a running Zigbee network and the button is only going to work in Home Assistant – go with Zigbee. Faster, more reliable, no additional gateway needed. If you’re committed to Matter long-term or running multiple platforms in parallel, the official route is the better choice.

Links from the video

If you’d like to support via Amazon: using this link earns me a small commission – regardless of what you buy, the price stays the same for you. Thank you.

Raspberry Pi out, ZimaBoard in – this surprised me

Wed, 13 May 2026 00:00:00 +0200

I’m not someone who touches a home server when it’s running. My Raspberry Pi 4 had been rock-solid for years, handling Home Assistant, MQTT, InfluxDB and a handful of other services – and I was, honestly, content with it. Not excited, but content.

Then an email arrived from IceWhale.

A board I hadn’t ordered

The pitch came in late March, and unlike most collaboration requests that get my channel name wrong or offer razors to a smart home channel, this one was targeted: You’re running a local stack with Home Assistant and MQTT – want to try it on a ZimaBoard 2?

I was skeptical. Not about the board – about myself. Someone who hasn’t fundamentally touched their Pi stack in years doesn’t just adopt a new platform on a whim. It’s work. It’s risk. And in the worst case, the smart home is down for days.

Then I looked at the specs. Then I ran the benchmarks. And then the decision had basically already made itself.

The old setup – what was actually running

For years, this was my home server foundation: a Raspberry Pi 4 with 8 GB RAM, Debian on top, and a whole zoo of Docker containers on top of that. Home Assistant, Mosquitto, InfluxDB, Grafana, Paperless-ngx, Zigbee2MQTT, Pihole, DiyHue – all on a single board. For storage, a SATA SSD was attached via a USB adapter, because SD cards for a 24/7 system had felt too risky for a long time.

The whole thing sat in a 3D-printed case with a 12 cm fan on top. I was genuinely proud of that case back then. It did its job. Quiet too.

That was my stack – the old Pi setup on the left, what runs now on the right. The video explains the difference better than any description, but the most important change at a glance: instead of everything flat in Docker, the ZimaBoard now runs Proxmox, with a Debian VM for the Docker stack underneath, and two lean LXC containers for Pihole and DiyHue. Cleaner, more flexible, and services no longer step on each other.

Why the Pi wasn’t actually ideal

Here’s what surprised me most – not the new features of the ZimaBoard, but what I’d forgotten about my old setup.

The biggest weak point was storage access. Attaching an SSD via USB sounds harmless, but it costs you: every write operation goes through the USB controller, the CPU has to assist, and peak latency under load hit 196 ms. Those are the small stutters you sometimes feel in Home Assistant – loading the interface, saving an automation, writing to InfluxDB. You get used to it. You start thinking it’s normal.

It isn’t.

The ZimaBoard has a native SATA connection – no USB detour, no controller overhead. Peak latency in the same test: 46 ms. Double the throughput, 76% less latency, and the Intel N100 barely breaks a sweat.

Power draw increases slightly: from around 8 watts to 12 watts. Four watts more, roughly €10 per year. I think that’s a fair trade.

What’s in the video

The full migration – including the snags I ran into along the way – is in the video. I show:

What migrating a running Docker stack to a new platform actually looks like in practice
Why Proxmox as a hypervisor makes more sense for a home server than bare Debian
How to pass a Zigbee USB stick through to a Proxmox VM
What I’d do differently next time – and there is something

And at the end I ask a question where I genuinely need your input. The context explains itself in the video.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Try the board yourself

If you want to test the ZimaBoard 2 yourself: IceWhale set up a discount code for my channel. With smarthomeabersicher15 you save $15 in their shop. I get a small commission, you don’t pay more.

👉 ZimaBoard 2 in the IceWhale Shop (affiliate link)

👉 2-Bay HDD Rack Tray for ZimaBoard 2 (affiliate link)

This video was made in collaboration with IceWhale – the board was provided to me at no cost. The technical assessment and everything I say is my own opinion.

The Automation You Never Want – But Must Have

Wed, 29 Apr 2026 18:00:00 +0200

My first video about the XSense smoke detectors surprised me a little. Not because of the numbers – but because of one particular moment in the video.

I’d briefly mentioned what I’d built for the Home Assistant integration: when a smoke detector goes off, all lights come on, all blinds go up, and I get a push notification on my phone. Just a quick aside because it fit the topic. But those few seconds apparently triggered something – in the comments, and at XSense itself.

How this video came about

Shortly after publishing the first video, XSense reached out. I explained the blind and automatic light idea in an email – and they found it so interesting that they asked me to make a detailed video about it. Show exactly how it’s built. What happens step by step. And why.

So here it is.

Why this automation matters more than it sounds

I’ll say it plainly: this isn’t a cool toy. This is an automation I hope you never need. But if you do need it, every second counts.

In a fire, two things rob you of the precious time to escape: disorientation and panic. Someone woken from sleep in the middle of the night often doesn’t immediately know where they are, where the door is, how to get out. And if everything is dark and the blinds are down – that’s a serious problem.

A well-designed automation can help counter exactly that. Not as a replacement for smoke detectors, escape route plans or fire extinguishers – but as one more layer that works silently and reliably when it matters.

What’s in the video

I build the complete automation live – from the MQTT entity of the smoke detector to the finished, tested automation chain in Home Assistant.

What happens when an alarm is triggered:

Push notification to your smartphone – immediately, even if you’re not home
All lights come on – escape routes become visible, no one stumbles in the dark
All blinds go up – windows become accessible as emergency exits, firefighters can see what’s happening from outside

I also show what to watch out for when building it so the automation works when it actually matters – including when the internet is down or Home Assistant just restarted.

And I explain why I deliberately didn’t add an automatic emergency call – it sounds like a good idea, but in practice it isn’t.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What have you already automated for emergencies at home? Write it in the comments – I’m genuinely curious how you’ve solved this.

The devices from the video

The XSense system the automation is built on:

6-pack starter set + base station (affiliate link): 👉 XS01-M 6-pack at XSense
12-pack + base station (affiliate link): 👉 XS01-M 12-pack at XSense
Discount code: AFQ3XSENSE → 12% off your entire order (X-Sense shop only, valid until September 30, 2026). Combinable with official website deals where applicable – during sitewide promotions the system automatically applies the lowest price (the code may then not apply at checkout), so just check the final price at checkout.
Alternatively via Amazon: 👉 XSense smoke detectors on Amazon (affiliate link)

This video was made in collaboration with XSense. Affiliate links: the price stays the same for you, but you support the work on my channel.

IKEA vs. Eve: Which Matter over Thread Sensors Win?

Thu, 16 Apr 2026 00:00:00 +0200

I hadn’t planned this at all.

The last video about Matter and Thread had barely been online for a week when the same question kept showing up in the comments: What about IKEA? First a few times, then more and more — until I couldn’t ignore it any longer. So I put both systems side by side and took a close look.

Honestly, the result surprised me.

A price difference that calls everything into question

IKEA sells a Matter over Thread window contact for around €8. The comparable Eve Door & Window sensor costs four times as much. And it’s similar for motion sensors.

That means concretely: you could equip your whole home with Thread sensors for under €100. That sounds almost too good. So — where’s the catch?

The answer is more complicated than expected — and depends heavily on what you’re actually trying to do.

What’s in the video

I go through five categories and take an honest look at each one:

Door/window contacts — For low-risk areas, IKEA does its job absolutely solidly. At the front door or combined with an alarm system, I’d personally still stick with proven solutions — not because IKEA is bad, but because Eve and Aqara have years of track record there.

Motion sensors — There’s a clear winner here: Eve. The IKEA sensor reacts noticeably slower and reportedly hangs occasionally according to user reports. For applications where response time matters, this is a real difference.

Smart plugs — Both measure energy consumption, which is far from a given at this price point. But Eve has a decisive advantage: the Eve Energy is a Full Thread Device — it actively strengthens your Thread network. The IKEA plug does not.

Water sensors — IKEA has a simple point sensor for ~€7. Eve delivers a 2-meter sensor cable that can be extended to over 100 meters — and costs accordingly. For simple protection under the kitchen sink, IKEA is perfectly adequate.

Air quality — Here IKEA surprises: the Alp Stuga measures CO2, particulate matter, temperature, and humidity for around €20. Eve currently has nothing comparable in their lineup. In testing, the readings are surprisingly close to much more expensive devices.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Team IKEA or Team Eve? Just write it in the comments — I’m curious who wins the vote.

Products from the video

Eve Systems (Matter over Thread, fully local):

Eve Door & Window – door and window sensor, Thread, runs forever on one battery (affiliate link)
Eve Motion – motion sensor, same principle, same philosophy (affiliate link)
Eve Energy – smart plug with energy monitoring (affiliate link)
Eve Thermo – radiator thermostat, Thread-based, no account needed (affiliate link)

For Home Assistant (Thread Border Router):

ZBT-2 Thread Border Router – the stick for Home Assistant to set up your own Thread network (affiliate link)

IKEA – the sensors shown in the video (Mittelpunkt, Mixspray, Clyppa, Alp Stuga) are available directly in the IKEA online shop. No hub needed if you’re using Home Assistant.

A small note: IKEA apparently doesn’t need an affiliate program — I recommend their products here anyway, but earn nothing from it. If you’d still like to support me: just do your next Amazon purchase through this link — whatever you buy, I get a small commission, and the price doesn’t change for you.

Is Zigbee dead now? Matter & Thread – 10 answers you need to know – The basics of Matter and Thread that this video grew out of

Is Zigbee Dead? Matter & Thread – 10 Key Answers

Wed, 01 Apr 2026 00:00:00 +0200

I’m about to buy an air purifier — the Bosch Air 4000i (affiliate link). Sounds unremarkable — and it would be, if not for a small note on the packaging: Matter over Thread or Matter over Wi-Fi.

There I stood. A device I consciously want to buy because it supports Matter — and I realized I actually had no idea what that concretely means. Matter has been part of smart home discussions for three years now. Three years. I’d kept catching glimpses of it, kept setting it aside. Probably not that important. Zigbee works just fine.

Then came the air purifier.

The moment that triggered this video

I’d planned to make a detailed video about that device — setup, Home Assistant, automations, the full package. But before I can do that meaningfully, I need to understand what’s actually happening under the hood. What is Matter? What is Thread? What do they have to do with each other? And why should I even pay attention to this when buying new hardware?

So I sat down and researched. Not just a quick Google — I really dived deep. Specifications, comparisons, forum posts, real-world tests. And I noticed: the information is out there, but it’s scattered everywhere, often technically overloaded, or stuck in the year 2022.

I’ve now summarized my research in a video — in the form of 10 questions and 10 answers that really help.

10 questions you’ll finally get a clear answer to

The chaos has many faces. Matter, Thread, Border Router, MoW, MoT — it’s easy to lose the overview. That’s why I picked the questions that came up for me — and that I keep reading in comments and forums.

#1 What’s the difference between Matter and Thread? — Constantly thrown in the same pot. But they’re fundamentally different things. I explain it with an analogy that really sticks.

#2 Do I need a new, expensive hub for this? — The honest answer is: sort of. When you need a Thread Border Router — and when your existing router is enough.

#3 Matter over Wi-Fi or Matter over Thread? — Both options are listed on the packaging. What you should choose depends on one single question.

#4 Why not just evolve Zigbee? — Thread uses the same chips. So why a new standard anyway? There’s more behind it than you’d think — and it has to do with IPv6.

#5 How does pairing work? — QR code, app, done. No cloud account, no manufacturer app, no subscription. It really is that simple.

#6 Is Zigbee dead now? — No. But the answer is more nuanced than you might expect.

#7 What about privacy? — For everyone who cares about local control — this is good news.

#8 Why do Thread devices sometimes go offline? — There’s a very specific, common reason for this. And an equally specific tip that solves the problem permanently.

#9 Is switching over worth it now? — My honest assessment, without sugarcoating.

#10 Which specific devices do I recommend? — One manufacturer committed early to Matter over Thread and consistently built their entire product range around it. I’ll introduce them.

All of that — compact, jargon-free, straight from real-world experience — is in the video:

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Where are you at with this topic? Do you already have Matter or Thread devices running, or are you still waiting? Just write “Thread”, “Matter”, or “Still waiting” in the comments — I’m genuinely curious where the community stands.

Devices from the video

If you want to get started right away, here are the products I recommend in the video — all Matter over Thread, fully local, no cloud dependency:

Eve Door & Window – door and window sensor, Thread, runs forever on one battery (affiliate link)
Eve Motion – motion sensor, same principle, same philosophy (affiliate link)
Eve Energy – smart plug with energy monitoring (affiliate link)
Eve Thermo – radiator thermostat, Thread-based, no account needed (affiliate link)
ZBT-2 Thread Border Router – the stick for Home Assistant to set up your own Thread network (affiliate link)

And the trigger for this whole video:

Bosch Air 4000i Air Purifier – Matter-capable, I’ll be making a separate hands-on video about it soon (affiliate link)

IKEA vs. Eve: Which Matter over Thread Sensors Are Really Worth It? – Came straight from the comments: a concrete price comparison of both systems

5 New Automation Mistakes in Home Assistant

Wed, 18 Mar 2026 00:00:00 +0200

It was a perfectly normal evening. I built an automation, started it — and it simply didn’t do what it was supposed to. No error in the logs. No red bar. Just: nothing.

After twenty minutes of searching, I found the mistake. And then something became clear to me: That wasn’t a one-off slip. That was a pattern.

My first video on the 5 most common automation mistakes was a hit back then — the comments went wild. And many of you wrote: “I knew all of these and still do them anyway.” I get it. I really do.

Since then, quite a bit has changed in Home Assistant. New features, new possibilities — and a whole new category of traps to fall into. Trigger IDs, for example. Or AI-generated automations that look so plausibly correct — and then aren’t.

I’ve picked out five of them. Five new mistakes I had to learn the hard way myself — and that I keep seeing when talking to the community. Some are insidious because the mistake only surfaces weeks later. One of them costs you all the progress of a running automation — at exactly the moment you least expect it.

Five mistakes that sound more harmless than they are

Mistake 1: The Trigger ID Trap

Trigger IDs are one of the features that have genuinely upgraded Home Assistant in recent years. You can finally consolidate multiple triggers in one automation and still tell them apart. Practical, elegant, modern.

And that’s exactly why this trap is so sneaky. Anyone who’s discovered the feature wants to use it for everything. Ten triggers, twelve conditions, a huge choose block — and at some point, actions fire that shouldn’t be firing at all. No error in the logs. Everything runs. Just wrong.

How to use trigger IDs properly — and where the line is — I show in the video.

Mistake 2: The light burns even when the sun’s still out

You built an automation: lights on at 6 PM. In October, that’s perfect. In March, the lamp is on while it’s still broad daylight outside. In December, you’ve been sitting in the dark for an hour.

Hard-coded times feel right when you set them up — and they get their revenge for the rest of the year. Most of us have at least one such automation hidden somewhere. Sometimes even several.

The good news: Home Assistant has everything you need to solve this permanently. What exactly — you’ll see in the video.

Mistake 3: The silent total loss

This is the mistake that surprised me most — and at the same time the one most people completely underestimate. You build an automation with a long wait action. Everything runs. At some point you apply an update. Home Assistant restarts.

And your automation? It remembers nothing. No hint, no log, no error message. The progress is simply gone. That can mean: a reminder is never sent. A lamp stays on. A door remains unnoticed open.

There’s an elegant solution for this — and it’s simpler than you’d think. But it requires a change of thinking. I explain how in the video.

Mistake 4: The script that silently refuses

Anyone who knows automation modes feels confident. Single, Restart, Parallel, Queue — that’s clear. But now here’s the trick question: Are you also keeping an eye on the modes of your scripts?

In the default mode Single, if a script is already running and gets called again, absolutely nothing happens. No error message. The script is simply ignored. Depending on your use case, your system then runs silently into the void — and you don’t know why.

Mistake 5: The automation that looks like a good idea

We use AI. That’s normal, that’s sensible, that’s fast. ChatGPT, Gemini, the built-in Home Assistant assistant — they can all deliver a first draft of an automation in seconds. And it looks good. Really good. Structured, plausible, commented.

The problem: ancient syntax from three-year-old training data. Entities that don’t even exist in your installation. Logic errors that only surface when they’ve already surfaced. AI code doesn’t check itself — you have to do that.

In the video, I show a real example and explain where you need to look especially carefully.

All five mistakes — with screenshots, real examples, and a look inside the automation editor — are in the video:

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Write in the comments afterwards which mistake got you the most — just the number, e.g. “Mistake 3”. That’s how I know what’s really on your mind.

→ If you want to secure your automations, the next step is security: Securing Home Assistant – 5 mistakes to avoid in your smart home

XSense Smoke Detectors Tested: How Secure Are They?

Wed, 11 Mar 2026 00:00:00 +0000

Imagine there’s a fire — and your smart home reacts instantly.

That’s exactly what I tried out with the new XSense smoke detectors. The special thing: they can be connected locally via MQTT to Home Assistant — completely without cloud dependency. In my test I didn’t just document the setup and integration, but also simulated the real emergency: what happens when the internet goes down? How reliable is the alarm chain? And how easy is the setup really?

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What to expect in the video

In this comprehensive test, I show you how the alarm chain works in practice, how far the radio range actually reaches, and how reliable the low battery warnings are. You’ll learn step by step how to get the MQTT integration working in Home Assistant, and I give you concrete tips for secure automations that protect your escape routes in an emergency and warn you with push notifications. At the end, I share my personal verdict and tell you who this system is really worth it for.

Curious? Then watch the video and find out how to make your home even safer!

Basics: Why networked smoke detectors?

In Germany, smoke detectors have been mandatory in all states since 2024 — in bedrooms, children’s rooms, and hallways that serve as escape routes. There’s a good reason for this: most fire victims don’t die from the fire itself, but from smoke inhalation — often at night while asleep, when you don’t notice the smoke in time. A smoke detector gives you the life-saving minutes you need to escape.

Interestingly, it’s not required that these smoke detectors be networked with each other — but that’s exactly where things get interesting. Imagine there’s a fire in the basement or a distant room of your home. You might not even hear a single smoke detector there, especially at night with closed doors.

Networked smoke detectors trigger together: when one detector detects smoke, all of them raise the alarm, and you’re guaranteed to be warned everywhere in your house. That can ultimately determine whether your escape route is still smoke-free or not.

The XSense system in detail

Specifically, I tested this networked smoke detector kit from XSense: six smoke detectors plus a central base station. The detectors are networked with each other and can trigger simultaneously in an emergency. The base station also serves as an interface to the XSense app and — this is new — to the local integration via MQTT in Home Assistant.

The base station comes with a power adapter, but it’s standard USB-C. I simply plugged it into the hub in my smart home server, saving an extra socket — a nice bonus.

The smoke detectors need to be paired once using the XSense app. That worked seamlessly for me and was done quickly. This step is necessary so that the detectors know each other and can reliably alert each other in a fire — even though this alarm communication doesn’t go through the base but directly between the detectors.

Safety first: smart home is an addition, not a prerequisite

Before we go deeper into the smart home integration, there’s one point I want to make particularly clear: smoke detectors are safety devices. The smart home connection is an addition, but must never be a prerequisite for an alarm to function at all.

That’s why I tested the behavior in a fire scenario first — using smoke detector test spray. Because the test button on the detectors often only simulates the acoustic alarm, but doesn’t test the optical smoke detection. The spray simulates real smoke particles and is also used for professional functional testing.

I must make an urgent warning here: never try to trigger a smoke detector with a lighter, a candle, or other smoke. The risk of irreparably damaging the detector in the process is enormous. And nothing would be more fatal than having the detector fail in a real emergency because you destroyed it during a test.

Alarm chain & radio range in the test

When a smoke event is detected, the affected smoke detector triggers locally first, and a few seconds later the other detectors connected in the home respond — provided they’re within radio range, of course.

The radio range is genuinely impressive: I live in an apartment building, and only beyond four floors did the connection become unreliable.

At the same time, the fire event is reliably displayed in the XSense app and — particularly relevant for us — the event is passed to Home Assistant via MQTT by the base station, where we can react to it.

Automations: what happens in an emergency

Based on this, I created an automation in Home Assistant that triggers a complete rescue chain in an emergency. First, it sends me a push notification to my smartphone so I’m immediately informed, even if I’m not home. At the same time, it automatically turns on all the lights in the house so escape routes are clearly visible and no one has to fumble around in the dark. And then something happens that might sound surprising at first: the automation raises all the blinds and roller shutters. Why? Simple — this frees up potential additional escape routes via windows, and the fire department can immediately see what’s happening in the house from outside.

This complete chain works reliably in my test: from the smoke event through the communication to other detectors, through the communication to the base, the display in the XSense app, the MQTT event transmission to Home Assistant, and the subsequent triggering of the automation.

Automatically alert the fire department?

Before anyone asks in the comments: could I theoretically use Home Assistant to automatically alert the fire department? Yes, technically yes — given the right interface to the telephone network.

But: legally and practically, I strongly advise against it! False alarms in Germany can result in costs and even legal consequences.

Offline function: integration without the cloud

I of course specifically tested the new offline functionality. When the XSense base station is switched on but offline, the app no longer works (logically — it needs a cloud connection). The local MQTT integration with Home Assistant continues to work as expected, however, since it runs completely locally in your home network.

To test this further, I disconnected the internet connection and deliberately triggered a low battery warning from a smoke detector by removing the battery and supplying it via a lab power supply with weak voltage. The MQTT message arrived in Home Assistant without any problems — even though the internet connection was down.

That’s exactly how a local integration should work: independent of cloud and internet, as long as the local network is stable.

Base station LED status

You can easily tell whether the base station currently has contact with the cloud by the LED in the center of the device. If it glows blue, everything is fine and the cloud connection is established. Yellow light signals that the cloud connection is interrupted — which, as we’ve seen, isn’t a problem for the local MQTT integration. If the LED glows red, the device is restarting. And if it’s completely off, that indicates a problem with the power supply.

Test button & MQTT integration

Manually testing the device (pressing the test button) is correctly displayed in the XSense app — there’s a notification that a test alarm has been triggered. However, this event is currently not yet forwarded via MQTT to Home Assistant.

I spoke with XSense support and learned that this is currently a limitation of the implementation. According to the manufacturer, this could be added in a future update — in my opinion, extremely useful for test scenarios, so I can test the entire signaling chain through to Home Assistant without having to use test spray.

The most important thing: primary safety independent of everything

The decisive point regarding safety: the networked alarm between smoke detectors always works — even if the power has already gone out.

Why? The answer is as simple as it is brilliant: every smoke detector has a built-in battery, and this networked alarm works exclusively via radio directly between the detectors. It requires neither contact with the base station nor an internet connection, let alone external power. The batteries in the detectors themselves are all that’s needed for the life-saving alarm chain.

I tried all conceivable combinations — with power to the base station, with internet, without internet. This function worked flawlessly every time.

The primary safety function (networking of the smoke detectors) is therefore not dependent on the app, MQTT, or a cloud connection. That’s exactly how it should be for a safety-critical system.

Battery life & replacement

The smoke detectors come with a battery included. According to manufacturer specifications, it should last one to two years — depending on how often you press the test button. I couldn’t verify this during the test period, of course.

The battery replacement itself is pleasantly straightforward — you can reach the battery compartment easily and are done quickly. And don’t worry about forgetting the replacement: you’ll be warned about a low battery on every conceivable channel. The detectors start briefly beeping every few minutes, the XSense app signals a weak battery, and this is of course also forwarded via MQTT to Home Assistant. So it’s practically impossible to overlook the needed battery replacement.

Setup: MQTT integration step by step

For anyone who wants to set up the system practically, here are the steps for MQTT integration:

Prerequisites and first steps

Before you start, make sure your base station is running at least firmware version 1.7.0. The app version should also be as current as possible to use all functions.

Setup begins in the XSense app, where you first go to “My Devices” and select the base station. In settings, check the firmware version and update if needed. You then find the “Connect with Home Assistant” option under the device settings. There you activate the MQTT connection and enter the IP address of your MQTT broker.

Authentication — this is where it gets tricky

Now comes the part where many people stumble. If you’re using Home Assistant OS, things are relatively straightforward: install the MQTT add-on if not already done, then enter your Home Assistant username and password. The reason is simple — the MQTT broker that comes with Home Assistant is typically secured with exactly these credentials.

With a different setup, like mine, things look different. Here you must not enter the Home Assistant credentials, but the authentication data for your MQTT broker — in my case, Mosquitto, for example.

Even if the app says “Home Assistant credentials,” don’t be confused. The manufacturer’s guide focuses on Home Assistant OS users, where Home Assistant and MQTT broker require the same credentials.

After successful activation

If everything works, you’ll see “MQTT status: connected”, regardless of your setup.

In Home Assistant, after successful activation, multiple entities appear automatically. You can see the status of each individual smoke detector, the current battery status, the connection status to the base station, and of course the crucial alarm entities with which you can build your automations.

All sensors are neatly grouped as devices, and each smoke detector appears as an independent device with its own entity. This makes it very easy and clear to use in automations.

Note on naming: If you’ve already named your smoke detectors in the XSense app and assigned them to rooms, that’s not transferred via MQTT. You’ll see the detectors in Home Assistant with their technical name (serial number) and then assign them to the correct rooms using the usual Home Assistant procedures. Once you’ve done that, you’re done.

My verdict: Who is this system for?

The smoke detectors fulfill their core task reliably and autonomously. The smart home integration via MQTT works very cleanly and reliably for real fire events or other safety-critical events like low battery status.

Personally, I’d be happy if XSense expands the interface further and also signals the test button press via MQTT, so I can test my Home Assistant automations more easily.

Who is this system worth it for?

Let me be honest about who I’d recommend this system to. First, there are Home Assistant users who want to use networked smoke detectors and value local integration. For this group, the setup is definitely worth a look. But even if you don’t use Home Assistant, the system can be interesting — provided your smart home solution supports MQTT. Then you can integrate the smoke detectors locally and benefit from the same advantages. And even if you don’t want any smart home connection at all, you get a classic networked smoke detector system here that works completely reliably without the app and base station in a fire situation.

If the setup interests you, here are the links to the tested set:

Directly from XSense: 👉 XSense Smoke Detector Starter Set with discount code AFQ3XSENSE (12% off your entire order, valid until September 30, 2026). Combinable with official website deals where applicable – during sitewide promotions the system automatically applies the lowest price, so just check the final price at checkout.
Alternatively via Amazon: 👉 XSense Smoke Detector Starter Set on Amazon (affiliate link)

This video was supported by XSense and the devices were provided to me free of charge. Affiliate links: your price stays the same, but you support the work on my channel.

Smart Garage with Shelly Blue: Door, Light & More

Thu, 05 Mar 2026 00:00:00 +0100

About a year ago I had a deceptively simple idea for a video: just show how I made my garage door smart with a Shelly. No big concept, no elaborate production — it was roughly my third video on this channel. I sat at the editing table that evening, thought “well, somebody will find it interesting” and clicked publish.

I had absolutely no idea what would come of it.

The video that changed everything

50 videos later, this garage door video is by far the most watched on the entire channel. Way ahead of everything I’ve produced since with considerably more effort. And what surprises me even more than the total numbers: it keeps attracting new viewers to this day. Not as a brief spike after upload, but continuously, week after week, year after year. People who want to automate their garage door, who are searching for a solution with Home Assistant, who just want to see what’s possible with a Shelly — they land there. Many stay.

I’ll admit: that left me speechless for a while. A spontaneous hobby video beats everything else. What does that say about YouTube? No idea. But it tells me something about you — and about the fact that this topic is clearly on a lot of people’s minds.

The moment that triggered this video

One winter not long ago, I was standing in the garage in the morning. I unplug the charging cable from the wallbox — and I’m standing in the dark. I’d forgotten the light. The garage door to the driveway was still closed. I feel my way to the switch, squeeze past the car, and think to myself: that’s ridiculous. I have a smart home. Why isn’t the garage smart?

A dumb question with a long answer — that I wanted to film.

Since then, I’ve gradually rebuilt everything. The light now turns on automatically as soon as I open the door or the garage door moves — controlled via Shelly BLU motion sensors and a Shelly Mini Gen3 that replaces the old impulse relay. And yes, the door now opens by itself when I unplug the charging cable in the morning. The logic runs directly on the devices, locally and independent of the cloud — even when my Home Assistant is applying an update and briefly unreachable.

It wasn’t always easy. Getting several Shelly BLU sensors bound locally to one actuator at the same time cost me a few evenings. But the result is a garage where I just drive in in the morning — and everything happens as if by magic.

What’s in the video

If you’re currently thinking about upgrading your smart garage — or finally want to tackle the garage door topic — you’ll find my complete current setup in the video. From the Shelly Blue Door Window Sensor for garage door state detection to garage lighting with motion sensors, the wallbox automation, and control via CarPlay and Android Auto. Everything from real-world use, nothing staged for the video.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

If the video helps you — or if you have your own experience with your garage in Home Assistant — feel free to write it in the comments. Not just because I’m genuinely curious, but because exactly these interactions help YouTube show the video to more people who are looking for exactly what you just found.

Hardware used

Shelly 1PM Mini Gen3* (also at OBI* or directly at Shelly* – code SMARTHOMEABERSICHER-10OFF for 10% off) – replaces the old impulse relay and switches the garage light
Shelly BLU Motion* – battery-powered Bluetooth motion sensor Or directly at Shelly* (code SMARTHOMEABERSICHER-10OFF for 10% off)
Shelly BLU Door/Window* – door/window contact for garage door state detection Or directly at Shelly* (code SMARTHOMEABERSICHER-10OFF for 10% off)

Make Roller Shutters Smart Safely with Shelly – Shelly modules for blinds: the same principle, different application
No More Annoying Thermostats! Shelly Makes Your Heating Smart – Shelly for heating control: autonomous, affordable, local
Repair BROKEN Shellys – the 30 CENT repair that actually works! – When old Shellys act up: a capacitor for 50 cents saves the device

DJI Robot Vacuum Hacked: 7,000 Living Rooms Exposed

Sun, 01 Mar 2026 00:00:00 +0100

A few days ago a press release turned up in my feed. I skim a lot of them every day – most I just scroll past. Not this one.

DJI. Robot vacuum. 7,000 strangers’ living rooms. A master key.

I read the article twice. And then I knew immediately: a follow-up video was needed.

The pattern that keeps repeating

If you’ve read my robot vacuum article, you might be nodding right now. Back then it was Ecovacs. Hacked robots remotely controlled in real time, chasing pets and shouting slurs through their speakers. I tried to explain back then why that wasn’t an absurd one-off incident, but a structural problem with this entire product category.

And now it’s happened again. Different manufacturer. Same category. Same fundamental vulnerability in principle.

This bothers me – not because I want to vilify robot vacuums, but because I believe most people who buy one simply don’t know what’s actually happening with their data. With the floor plan of their home. With camera footage, if the model has one. With the question of who, besides themselves, could theoretically access all of that.

What happened this time

It started innocuously. A French developer, a brand-new DJI robot vacuum, a free evening. The idea: control the robot around the apartment with a PS5 controller. Mario Kart in real life, but with dust bunnies.

To connect the controller, he needed the key from the app – nothing illegal, it was his own device. But when he used that key with the DJI server, the server didn’t just download his own data – it downloaded data from thousands of others. Over 7,000 robots across 24 countries. Battery levels, home floor plans, live camera feeds from strangers’ living rooms. The key wasn’t a normal key. It was a master key for the entire system.

DJI patched the vulnerability after it was reported. That’s good. But it doesn’t change the underlying picture.

Why I keep talking about this

After making this video I naturally asked myself whether I’m starting to get repetitive. Robot vacuums again. Privacy again. Same topic again.

But then I look at the comments under the old video. And I see how many people write that they simply hadn’t known how the technology behind it works. Not because they weren’t interested. But because hardly anyone explains it without immediately descending into panic or buzzwords.

That’s exactly what I want to do differently. No moralising, no fearmongering. Just: here are the facts. Here’s what they mean. And here are three concrete things you can do – if you want to. What you do with a camera-equipped robot vacuum in your home is your decision. I just want that decision to be an informed one.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

If you already have a view on this – or you have a robot vacuum at home and feel a quiet unease stirring – write it in the comments. I genuinely appreciate every perspective. And yes, every comment helps the video reach more people who are asking themselves exactly these questions for the first time.

Sources:

3 Smart Home devices I would buy AGAIN and again!

Sun, 01 Feb 2026 08:00:00 +0200

What makes a smart home device a true workhorse?

Many devices promise a lot – but which ones actually run reliably year after year? In my new video I share my personal top 3 that have been running without issues for years and genuinely improve my daily life.

Why I have 34 Shelly actuators installed and what makes them so special
How 7 Aqara motion sensors provide comfort and automation (and why I wouldn’t want to live without them)
What Homematic window contacts with 15 years of longevity teach you about “never change a running system”

👉 Curious? The video shows all the details, practical examples and my golden rules for long-lasting smart home installations!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Chapters & Topics:

Intro: What makes a good smart home device?
Shelly in-wall actuators: Reliability & favourite projects
Aqara motion sensors: Comfort gains & automation
Homematic window contacts: 15 years of staying power
Golden rules for smart home purchases
Community question & outlook

Join the discussion: Which device is YOUR smart home workhorse? What has been running absolutely flawlessly for you for years? Share your experience in the comments – your favourite might end up in the next video!

My three long-runners on Amazon (affiliate links): Shelly Plus 1 PM · Aqara Motion Sensor P1 · Homematic IP door/window contact — you’ll also find the Shellys at OBI as a 4-pack. Or directly at Shelly: Shelly (affiliate link, code SMARTHOMEABERSICHER-10OFF for 10% off)

Transparency: Some links in the video and blog are affiliate links. The price stays the same for you, but you support my work. Thank you!

3 Smart Home fails: devices I would NOT buy today!

Sun, 25 Jan 2026 00:00:00 +0200

Imagine: you get up in the morning, want to raise the blind – and nothing happens. Try the app? Nothing. Try the physical switch directly? Dead. And here’s the kicker: the fault is buried deep inside a wall-mounted junction box.

That was the moment I realised: my smart home had just turned into a nightmare. And I’m not alone with experiences like this.

Today I’m showing you three devices that made it very clear to me where smart home can really go wrong. Not theoretical problems – but real fails that cost me time, money and nerves. We’re talking about 14 actuators all failing. A robot vacuum that became useless overnight. And false alarms waking me up in the middle of the night.

Watch the video – I demonstrate the problems live and show you what you can learn from them.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Fail #1: Shelly 2.5 – When 14 actuators died at the same time

The slow death inside the wall

This is a Shelly 2.5 – an actuator for roller shutters and blinds. I have 14 of them installed. Fourteen! Nearly all in junction boxes, permanently wired behind wallpaper and plaster. My expectation was pretty clear: install once, close up, forget it. Set and forget.

On the software side I was happy for a long time: locally controllable, great Home Assistant integration, no cloud dependency. Exactly what you want.

And then the drama began.

The same defect – 14 times

In all – yes, literally all – of these Shelly 2.5 actuators, one component failed after some time, one by one. All fourteen, always the same defect. Morning routine, raise the blind? Nothing. App? Nothing. Physical switch? Dead.

Now here’s the real nightmare: these things are of course sitting in junction boxes. That means: open the wall, pull out the actuator, desolder the capacitor, solder in a new one, reinstall, close the wall. Per actuator. Fourteen times.

That was a genuine maintenance disaster for me. And I’m not alone. There are masses of reports about this Shelly generation online.

In the video I show you exactly what went wrong and how I carried out the repair. The detailed repair guide is in this separate article.

Small consolation: repair is possible

With a soldering iron you can swap the faulty component for a few cents in parts. Before that: breaker off and verify the circuit is dead, more in Working safely with mains voltage. But honestly: do you really want to open 14 wall boxes and replace capacitors?

Important note: this problem affects specifically the Shelly 2.5. The successors Shelly Plus 2PM and the Gen 3 and Gen 4 are ones I use heavily myself and have had zero failures with so far. So this isn’t about bashing the manufacturer across the board.

The key lesson

Wait for long-term community experience before buying new products. First generation? Let others be the testers. Second generation with solid reviews over a year? Then go ahead.

Fail #2: Shark robot vacuum – When the cloud kills your integration

From smart home star to useless appliance

The second device frustrated me in a completely different way. It’s about my Shark robot vacuum. And upfront: the hardware is perfectly fine. It vacuums well, navigates decently, does its job.

For months I had it deeply integrated into my smart home. Built automations along the lines of: “When nobody’s home, start cleaning.” The Home Assistant integration ran perfectly. This wasn’t a toy – it was a solid, reliable part of my daily routine.

Watch in the video how well the system worked – before everything fell apart.

One app update. One dead integration.

And then, one morning: automation triggers – nothing happens. Home Assistant shows: connection lost. Maybe a bug? Open the app – it works. Robot starts via app. But the Home Assistant integration? Dead. Still dead weeks later. Permanently.

What happened? The Shark app had updated itself automatically – as apps do. Completely normal, in the background. Without me actively deciding anything or consciously triggering it.

But with this update, something had changed in the cloud interface. The result: the Home Assistant integration was broken. No workaround, no fallback, no local API.

The moment of realisation

That was the moment I understood: I didn’t buy a device I’m in control of. I bought a device whose capabilities can change at any time via a server update. Without my consent. Without warning. And I can do nothing about it.

In the video I explain in depth why this is a fundamental problem with many cloud-dependent devices.

Imagine buying a car – and a year later the manufacturer says: “Sorry, the radio only works with our app now.” That’s exactly what happened here. Except that the “radio” in my case was the entire smart home integration.

The lesson: an exit strategy is mandatory

Cloud is convenient – but you always need an exit strategy.

Is there a local API?
Can I flash alternative firmware?
Does the device work without internet?

Bose recently handed us a similar case. If that interests you, here’s the article about Bose SoundTouch.

Fail #3: Sonoff Zigbee motion sensor – The night-time false alarms

Bought cheap, paid dearly

The third device looks harmless at first glance: a Sonoff Zigbee motion sensor. Cheap, bought 10 of them, quickly integrated, classic use case for lighting automations.

And at first I thought: okay, maybe a bit sensitive. Adjust the calibration, reduce the range, tried everything.

But then reality hit:

The night-time horror

Middle of the night – light comes on. I wake up, fall back asleep. Half an hour later: again. Three, four times per night. After two weeks I was nearly going mad.

I first thought: a bug in my automation. Checked all the logs. But no: the sensor is genuinely reporting motion. Where there isn’t any.

Same during the day. Light comes on when nobody’s in the room. Shadow from outside? Reflection? An insect on the sensor? No idea. But it doesn’t matter – because the result is the same: the system isn’t reliable.

In the video I demonstrate what these false triggers feel like and what impact they have on your trust in the system.

Unreliability is the death of any automation

In my view, this is the death of any automation. Because sooner or later you start disabling automations. Deactivating sensors. You lose trust in the system.

I replaced these sensors consistently with Aqara motion sensors. More discreet, significantly more reliable – and suddenly the system works. No more false triggers. No more waking up at night. Just: it works.

Not a brand problem, but a product problem

Important: this isn’t a general Sonoff problem. I use plenty of other Sonoff devices myself – Sonoff Basic or S20 plug switches for example – flashed with Tasmota. Local, no cloud, rock-solid for years. Except once, a capacitor issue there too – but that stayed a one-off.

The motion sensor is therefore a specific product problem, not a brand problem.

The lesson: test first, then scale up

Test sensors in everyday use before buying ten of them. One sensor for €10 is cheap – but ten faulty sensors are €100 of e-waste.

Unreliable sensors cannot be “optimised”. No tuning, no configuration makes a bad sensor good. Replacing them decisively is the only solution.

Three golden rules for your smart home purchases

From these three fails I’ve developed three rules I explain in detail in the video:

Rule 1: Have an exit strategy

Ask yourself:

Is there a local API?
Can I flash alternative firmware?
Does the device work without internet?

If all the answers are “no” – think very carefully before buying.

Rule 2: Wait for community experience

Wait for long-term reviews. Read user reports. Only install critical actuators where you can reach them again if needed. So junction boxes only with absolutely proven hardware.

Rule 3: Test sensors thoroughly

Testing one sensor in real life for two weeks might cost you €10. Test first, then buy. Not the other way around.

The opposite: the best devices

If you want, in the next video I’ll do exactly the opposite: Three devices that have run absolutely reliably for years. That I would buy again immediately. That cost me zero maintenance.

Watch the video and write “YES” in the comments if that interests you!

Or do you have a smart home device you could throw against the wall? What was your biggest fail? I’m looking forward to your stories in the comments!

Open Source Saves Bose SoundTouch – Bose Backs Down

Sun, 18 Jan 2026 00:00:00 +0000

The Turnaround: When Community Pressure Works

Update to my article from November 2025: Remember? Bose wanted to shut down the cloud for SoundTouch, leaving €1,000 speakers stripped of their most important features. Now there’s a spectacular twist!

On January 12, 2026, Golem reported: Bose does a 180° and releases the SoundTouch speakers’ Web API as Open Source. The community has won!

In the video I walk you through the whole story – why this development affects EVERY smart home user, not just Bose owners. Because this is a precedent for the entire industry.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What Exactly Happened?

Make sure to watch the video – there I explain all the details. Here are the key points:

1. Bose Opens Up the API

Instead of simply shutting down the cloud, Bose has now released the Web API as Open Source. This allows developers to build their own solutions and use the speakers without the Bose cloud.

Bose’s reasoning: They want to “support the open-source community” and give interested parties “the opportunity to develop alternatives.”

This is a complete reversal from the original “we’re just pulling the plug” approach. In the video I show why this is so significant!

2. More Time for Development

The shutdown was pushed back from February 2026 to May 6, 2026. This gives the community three additional months to develop working alternatives.

3. The App Stays Available

Originally, Bose planned to remove the SoundTouch app entirely from the Play Store and App Store. That was reversed – the app remains available.

The Community Was Ahead of Bose

The most exciting part of this whole story: the open source community was ahead of Bose!

Before Bose even released the API, there were already projects on Github working to keep the speakers usable after the server shutdown. Those projects can now be developed much more easily and reliably thanks to the official API release.

In the video I show you concrete examples of these community projects and explain what this means for the future.

What Still Works After May?

To be clear – the cloud is still being shut down. In the video I go into detail about what that means in practice:

❌ Gone after May 6, 2026:

Direct music streaming via the SoundTouch app
Reassigning station buttons (existing assignments may continue to work)
Cloud-based services (TuneIn, etc.)

✅ Still functional:

Bluetooth (with the usual range limitations)
AirPlay (for Apple users)
Spotify Connect (if you have a Spotify subscription)
Wired inputs (AUX, HDMI, optical)
Local playback control

Watch the video for a complete analysis of what this means in practice!

Why This Should Matter to You – Even Without Bose

This is the most important message of this article: This story affects every smart home user, not just Bose owners. In the video I explain in detail why this sets a precedent for the entire industry.

Three Important Lessons:

1. Community Power Works

Public attention, critical coverage, and active community engagement can push manufacturers to rethink their decisions. Bose could have simply pulled the plug – but didn’t.

In the video I show how public pressure made a concrete difference.

2. Open Source Protects Your Investments

The more open the systems, the less dependent you are on the manufacturer. Even if a manufacturer drops support, the community can take over the project.

In the video I analyze what this means for your future buying decisions.

3. New Buying Criteria for Smart Home

Before your next purchase, ask:

Is there an open API?
Does an active community exist?
Does the device work locally without the cloud?
Are there already open source alternatives?

In the video I give you a detailed checklist for your next smart home purchase.

What Does This Mean for Other Manufacturers?

The Bose case sends a clear signal to Vorwerk, Belkin, Logitech, Philips, and all other manufacturers shutting down their cloud services:

In the video I explain why manufacturers can actually benefit from this development:

Save their reputation instead of permanently damaging it
Retain existing customers instead of losing them
Build trust for future products

Watch the video for the full analysis!

Practical Tips for SoundTouch Owners

If you own a SoundTouch speaker, in the video I show you exactly what you should do now:

Stay informed: Follow the Github projects and community forums
Test alternatives: Try out Bluetooth, AirPlay, or Spotify Connect now
Support the community: If you can code – join the open source projects!
Be patient: The projects still need time until May 6, 2026

All links to the community projects can be found in the video description!

Conclusion: A Win-Win Situation

At the end of the day, this is a win-win for everyone involved:

For Bose: Cloud costs saved, reputation partially rescued
For users: Devices remain usable, new possibilities through open source
For the community: An important precedent for the future

This shows: Smart home can be sustainable – when manufacturers and communities work together rather than against each other.

In the video I analyze what this development means for the smart home industry in the long run.

Connection to My First Article

This article is an update to: When Your Smart Home Suddenly Gets Dumb – and What You Can Do About It

There I described the problem; here I show the resolution. Exactly how it should work!

Sources and Further Links

Did this article help you? Share it with other SoundTouch owners! For more articles on secure and sustainable smart home solutions, browse the rest of the blog.

Scan this code with your banking app!

Zigbee Soil Moisture Sensor Tested: Never Overwater

Sun, 11 Jan 2026 08:00:00 +0200

Does this sound familiar? You’re standing in front of your potted plants wondering: Is the soil too dry or too moist? Should I water now or hold off? Especially with a drip irrigation system, this question keeps coming up.

A Zigbee soil moisture sensor promises to help – finally delivering objective data instead of guesswork. But does the device actually hold up in practice? I’ve been testing the NEO Zigbee Soil Moisture Sensor for two weeks in everyday use – with Home Assistant and Zigbee2MQTT.

See the results in the video!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The Problem: Watering by Feel

Potted Plants and Drip Irrigation

I have several potted plants on my balcony and installed a drip irrigation system a while back. Sounds smart – but the question remains:

How do I set up the irrigation correctly?
Is the soil too dry or too moist?
Am I watering too much or too little?

This is exactly where the soil moisture sensor comes in: Objective measurements instead of gut feelings!

The NEO Zigbee Soil Moisture Sensor

What Can It Do?

The NEO Zigbee Soil Moisture Sensor (model NAS-STH01B2) measures two important values:

Soil moisture in percent – how moist is the soil?
Soil temperature – how warm is the ground?

The device communicates via Zigbee and runs on three AA batteries. It is specifically designed for outdoor use – for indoor plants it would simply be too large.

In the video I show the device in detail and explain what to watch out for during installation!

OEM Products: Why Do So Many Look the Same?

Watch out: If you search for soil moisture sensors on Amazon, you’ll notice that many devices look exactly the same – just with different brand names.

The reason: NEO is a so-called OEM manufacturer (Original Equipment Manufacturer). This means:

The hardware comes from NEO
Other companies sell it under their own name
Technically the devices are identical

The price can vary significantly though – currently between €20 and €30 on Amazon. A different price doesn’t automatically mean better or worse technology. Often you’re simply paying for branding.

In the video I explain the concept in more detail and show you what to look for when buying!

Build Quality and Housing

How Good Is the Quality?

Especially for sensors that sit in moist soil outdoors, build quality is crucial. I took a close look at the device:

The package contents are exemplary:

Battery cover secured with a screw
Remaining screws including a screwdriver included in the box
Rubber plugs for sealing against moisture

Inserting Batteries and Sealing the Housing

The battery compartment holds three AA batteries in a somewhat unusual arrangement. After inserting the batteries, the screws are tightened and the rubber plugs inserted to seal the housing against moisture.

One important point: According to the instructions, the metal prongs should be completely in the soil for correct measurements.

In the video you can see every step of the installation live!

Integration in Home Assistant with Zigbee2MQTT

Zigbee Pairing: Unremarkable and Quick

Connecting to Home Assistant via Zigbee2MQTT was done in a matter of seconds:

Press and hold the button – activate Zigbee pairing
Sensor is automatically detected – done!

Several entities then appear:

Soil moisture (in percent)
Temperature (in 0.5-degree steps)
Battery status
Additional entities such as alarms or thresholds

The extra entities come from the Tuya app world. In Home Assistant I honestly don’t need them – I prefer to build my own automations directly in Home Assistant.

Temperature in 0.5-Degree Steps

One notable point: The temperature is reported in 0.5-degree increments. This may seem coarse at first, but is completely normal:

Either the sensor resolution is that precise
Or it’s a deliberately set Zigbee reporting threshold to save battery

For plant care, 0.5-degree steps are more than sufficient!

In the video I show you all the entities in detail and explain which ones are really useful.

Real-World Test: Two Weeks in Everyday Use

How Do the Readings Behave?

I had the sensor log data in Home Assistant for two weeks. The result:

The readings appear plausible
With dry soil the value drops continuously
After watering it rises noticeably
With a small time delay – completely normal

The Zigbee connection was flawless – no dropouts, no connectivity issues.

Battery Status: Useful?

Some Zigbee devices perform poorly when it comes to battery status – delivering completely unreliable values. With the NEO sensor I can’t make a final judgment after just two weeks.

Should I notice anything unusual, I’ll report back in the video description, in the comments, or in an additional update video.

I cover all of this in the video – make sure to watch it!

Why Three AA Batteries Instead of a Coin Cell?

Active Measurement Needs More Power

You might be wondering: Why three AA batteries, when other Zigbee sensors get by with a CR2032 coin cell?

The answer is simple:

Soil moisture is actively measured – current flows through the soil between the metal prongs
This requires significantly more energy than, for example, a door contact or temperature sensor
Zigbee itself is extremely efficient – the energy consumption primarily comes from the measuring principle

The stated runtime of approximately one year is on the conservative side. How long the sensor actually lasts in practice remains to be seen.

Alternative: Version with Solar Panel & Rechargeable Battery

Good news: There’s also a version with a built-in solar panel and rechargeable battery instead of disposable batteries. If you want to avoid changing batteries, you can find this version in the product list as well.

In the video I explain both versions in detail and show you which one is right for you!

Assessment & Conclusion

No High-Tech Precision – But Practical!

The NEO Zigbee Soil Moisture Sensor is not a high-tech instrument for scientific accuracy. But it doesn’t need to be!

Who is the sensor suitable for?

✅ Home Assistant users with Zigbee2MQTT or other Zigbee platforms
✅ Plant enthusiasts who want objective data instead of gut feelings
✅ Budget-conscious users – no €100+ like professional sensors

What you should not expect:

❌ Scientific accuracy
❌ A maintenance-free solution for decades
❌ Comparability between different pots/plants

But as a pragmatic helper in everyday life it works well for me – and I wouldn’t want to be without it!

All details, impressions, and live demonstrations are in the video – be sure to watch it!

Write in the comments:

Are you already using soil moisture sensors?
What has your experience been?
Or are you still watering by feel?

Hardware links:

Zigbee Soil Moisture Sensor with batteries (NAS-STH01B2): on Amazon*
Zigbee Soil Moisture Sensor with solar & rechargeable battery: on Amazon*

(affiliate links – as an Amazon Associate I earn from qualifying purchases)

Home Assistant A-Z: O is for Offline – No Internet?

Sun, 04 Jan 2026 00:00:00 +0200

A Confession at the Start of 2026

Time for a confession: I turn off my Fritzbox every night – completely on purpose! And yes, my smart home keeps running anyway. It wasn’t always like that and took some work to get right. But why is it even worth checking whether your smart home still works offline?

The answer is simpler than you might think. Watch the video and find out why you should review your automations – even if you’d never dream of switching off your own router!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Why Offline Functionality Matters

You don’t have to be as radical as me and deliberately cut your internet connection. Still, it’s worth understanding when your smart home works offline and where it might silently fail.

Internet Outages Are Not Rare

You won’t always be offline by choice. It happens like this too:

The internet goes down (ISP outage, broken router)
Certain servers become unreachable (cloud services down)
Wi-Fi issues in individual rooms

In all of these cases, your smart home should reliably keep running for core functions!

The Smart Bed Example

A particularly striking (or alarming?) example: a smart bed costing $3,000. When Amazon’s cloud servers went down, users had a serious problem:

❌ The sleeping position could no longer be adjusted
❌ Temperature regulation stopped working
❌ Users were stuck sleeping in uncomfortable positions or sweating through the night

In practice, it doesn’t matter whether Amazon’s server has issues or your internet connection does. The effect would be the same either way.

A Real-World Example From My Smart Home

Let me show you with a concrete example from my own smart home. In the video you can see the automation live, and I walk you through every step in detail!

The Window Reminder Automation

This automation reminds me when I leave a window open in cold outdoor temperatures, to prevent the apartment from cooling down unnecessarily.

Here’s how it works:

Trigger: One of several windows is opened
Condition: Outdoor temperature is below 18°C
Action: After a set amount of time, a reminder to close the window

The Problem With Cloud-Based Sensors

Originally I was relying on my weather sensor – specifically the temperature from a weather forecast integration. If you watch the history in the video, you’ll spot the problem immediately:

At night the sensor was unavailable (which makes sense – I’m cutting the internet, after all).

This meant:

The automation cannot evaluate the condition
The condition is treated as “false”
The automation stops and doesn’t continue
I get no warning, even if it’s freezing outside!

The Fix: Use Local Sensors

The solution was straightforward: I have a heat pump in the basement with an outdoor temperature sensor connected to Home Assistant via MQTT.

Advantages: ✅ The sensor is always available (local via MQTT)
✅ No dependency on internet or cloud
✅ Automation runs reliably even at night

In the video I show you exactly how I updated the conditions!

Resilient Automations With Fallback Values

But simply swapping the sensor isn’t enough. You also need to handle failures gracefully.

Float Conversion With a Default Value

In the automation I check:

1

{{ states('sensor.waermepumpe_aussentemperatur') | float(default='none') }}

What’s happening here?

The sensor value is converted to a floating-point number
If that fails (e.g. sensor unavailable), none is returned instead
This lets me react in a controlled way rather than having the automation abort

Safety Through Fallback Logic

My final condition:

1

Is the temperature = none OR below 18°C?

In both cases the automation should continue running!

Why? Better to be warned once too often than once too few. If I can’t read the value, I assume the worst case: it might be cold, so warn me anyway!

In the video you can see the complete logic step by step!

Second Example: Variable Wait Time

In the same automation I use a variable wait time depending on outdoor temperature:

10°C outside → window can be open for up to 10 minutes before a warning
5°C outside → window can be open for up to 5 minutes before a warning
Below 5°C → minimum wait time of 5 minutes

Here too I had originally used the weather sensor – with the same problems!

The Resilient Solution

1

{{ [states('sensor.waermepumpe_aussentemperatur') | float(default=0), 5] | max }}

What does this do?

Temperature is read and converted to float
On failure: default value of 0
Take the maximum of the temperature and 5
Result: At least 5 minutes, up to 18 minutes (when the condition fires)

This way the automation works reliably even when a sensor is unavailable!

Want to see the exact implementation? Watch the video – I show you the automation live inside Home Assistant!

How Do You Identify Offline-Dependent Integrations?

An important question: How do you even know which integrations require internet access?

In the video I show you:

Weather integration (requires internet):

Home Assistant explicitly labels it as “Cloud Polling” or similar
Not available without internet

MQTT integration (no internet needed):

Connects to a local MQTT broker
Works completely offline

Tip: Take a look at your integrations in Settings. Home Assistant usually marks cloud-based integrations clearly!

Why I Turn Off the Fritzbox at Night

In case you’re wondering why I do this at all:

My reasons:

Save standby power: Around €10–15 per year
Sustainability: I simply don’t need internet at night
Testing smart home resilience: Forces clean solutions
Smartphone falls back to LTE: I remain reachable regardless

It took some thought to get everything in the smart home working properly. But now I’m happy with it!

Important: You don’t have to do the same. This is a personal choice. The lessons from it, however, apply to everyone!

My Three Most Important Tips for You

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

You don’t need to turn off your router. But these three things are worth keeping in mind:

1. Make Core Functions Work Offline

Make sure these functions work without internet:

✅ Lights
✅ Blinds and shutters
✅ Heating
✅ Security functions

These are essential to your home. They must not depend on an internet connection!

2. Comfort Functions Can Be Dependent

Comfort functions that you don’t strictly need can rely on internet services:

Weather forecasts on the dashboard
Voice assistants
Cloud notifications
External data sources

That’s perfectly fine – as long as the core functions keep working!

3. Review Your Automations for Resilience

Go through your automations:

Which sensors are used?
What happens if a sensor becomes unavailable?
Are there sensible fallback values?
Does the automation abort on errors or continue in a controlled way?

This is an improvement you won’t notice every day. But when it matters, you’ll be grateful your smart home still runs reliably!

Conclusion: Resilience Is Not Rocket Science

As you can see, resilient automations are not rocket science. All it takes is:

Awareness of which sensors are available offline
Controlled error handling with default values
Sensible fallback logic instead of automation aborts

Watch the video to see everything live and explained step by step. Once you’ve gone through your own automations, I’d love to hear what you found!

Feel free to write your thoughts in the comments below the video or this article.

Home Assistant A-Z: N is for Night Mode

Sun, 28 Dec 2025 00:00:00 +0000

Welcome to the A-Z Series: N is for Night Mode

In today’s episode of the Home Assistant A-Z Series we tackle a topic that every smart home user knows: How do you stop your hallway from lighting up like an airport runway in the middle of the night?

The answer is: night mode! But not just any night mode – today I’ll show you how to use a central Smart Home status to intelligently control all your automations. From dimmed night lights to closed blinds to gentle radio as you drift off to sleep!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The Problem: Being Blinded at Night

Sound familiar? You wake up in the middle of the night, need a quick bathroom trip, step into the hallway – and BAM! Full brightness hits you square in the face. Your eyes need five minutes to recover. Any chance of relaxing back to sleep is gone.

It doesn’t have to be this way! With an intelligent night mode you can:

✅ Use dimmed night lights instead of full brightness
✅ Navigate without being blinded
✅ Fall back asleep quickly after your midnight trip
✅ Automatically adapt multiple rooms (hallway, bathroom, etc.)

And the best part: All of this works automatically, without you having to manually switch anything!

In the video I show you the problem and the solution live!

The Secret: A Central Smart Home Status

Many Home Assistant users build complicated automations with dozens of conditions. “If the time is between 10 PM and 6 AM AND nobody is in the living room AND…” – it quickly becomes a mess.

My solution: A central Smart Home status that reflects the current state of your entire home!

What is a Smart Home Status?

Talking to other smart home users, I keep noticing: many people don’t bother maintaining a status in their smart home. Yet it is incredibly useful!

A status is simply a Helper (Input Select) that represents the current state of your smart home.

My four states:

Present – Normal operation, everyone is home
Night – Someone has gone to bed
Away – Nobody home
Vacation – Extended absence

That’s it! These four states are enough to keep all my automations running appropriately.

In the video you can see the status live on my dashboard, including the history of the last 24 hours!

Why is a Status so Powerful?

The big advantage: your automations become much simpler!

Instead of:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


condition:
 - condition: time
 after: "22:00:00"
 before: "06:00:00"
 - condition: state
 entity_id: group.all_persons
 state: home
 - condition: state
 entity_id: media_player.wohnzimmer
 state: 'off'

You simply write:

1
2
3
4


condition:
 - condition: state
 entity_id: input_select.smart_home_status
 state: 'Nacht'

Much more readable, maintainable, and flexible!

Live: My Smart Home Status

Let me show you my status live. I have a helper called “Smart Home Status”.

Currently set to: “Anwesend” (of course – I’m recording a video right now!)

In the history of the last 24 hours you can see:

🟢 Present (daytime)
🌙 Night (from roughly 10:30 PM to 6:30 AM)
🟢 Present (after waking up)

The status is set automatically and moves through different phases over the course of a normal day.

Make sure to watch the dashboard in the video – the visualization makes it even clearer!

How is the Status Set Automatically?

Of course I don’t want to open the dashboard every evening and manually click “Night”. That would be absurd!

That’s why I have various automations, all with the goal of changing the status.

Trigger 1: Zigbee Button by the Bed

The most important automation: I have a Zigbee button next to my bed (e.g. an Aqara Wireless Mini Switch).

When I press it:

Status switches to “Night”
An automation cascade is triggered (more on that in a moment!)

This is perfect, because the button press marks the exact moment when I go to bed – not some arbitrary time, but precisely when I want to sleep.

In the video I show you the button and the automation!

Trigger 2: Alarm in the Morning

In the morning, when my alarm goes off, an automation lifts the Night status again:

1
2
3
4
5
6
7
8
9


trigger:
 - platform: time
 at: input_datetime.wecker_time
action:
 - service: input_select.select_option
 target:
 entity_id: input_select.smart_home_status
 data:
 option: 'Anwesend'

The entire smart home wakes up along with you!

Trigger 3: Absence

When all household members leave home, the status switches to “Away”:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


trigger:
 - platform: state
 entity_id: group.all_persons
 to: 'not_home'
 for: "00:05:00"
action:
 - service: input_select.select_option
 target:
 entity_id: input_select.smart_home_status
 data:
 option: 'Abwesend'

Check out all the trigger automations in the video!

The Automation Cascade When Night Mode Activates

When the status switches to “Night”, it doesn’t just trigger one thing – it sets off a whole cascade of automations!

What Happens Automatically:

1. Blinds close

All blinds in the bedroom – and possibly the living room – close automatically:

1
2
3
4
5
6
7
8
9


trigger:
 - platform: state
 entity_id: input_select.smart_home_status
 to: 'Nacht'
action:
 - service: cover.close_cover
 target:
 entity_id:
 - cover.rollladen_schlafzimmer

2. Bedroom light dims

The bedroom light is dimmed to a very low brightness and then fades out slowly over a 10-minute ramp:

1
2
3
4
5
6


- service: light.turn_on
 target:
 entity_id: light.schlafzimmer
 data:
 brightness: 10
 transition: 600 # 10 Minuten

3. Radio plays softly

A radio turns on at low volume, giving me some entertainment as I fall asleep:

1
2
3
4
5
6
7
8


- service: media_player.turn_on
 target:
 entity_id: media_player.schlafzimmer
- service: media_player.volume_set
 target:
 entity_id: media_player.schlafzimmer
 data:
 volume_level: 0.15

All of this happens with a single button press! Simple, elegant, reliable.

In the video I show you the complete automations in detail!

The Core Feature: Night Light Instead of Main Light

Now here’s the real trick of night mode: intelligent light control!

My Hallway Setup

In my hallway I have two different lights:

Main light (bright ceiling lamp via Shelly)
LED strip on a built-in cabinet (dimmed as a night light)

The goal: During the day the main light should come on; at night, only the dimmed night light!

The Night Light Automation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


alias: Flur Nachtlicht bei Bewegung
trigger:
 - platform: state
 entity_id: binary_sensor.bewegungsmelder_flur
 to: 'on'
condition:
 - condition: state
 entity_id: input_select.smart_home_status
 state: 'Nacht'
action:
 - service: light.turn_on
 target:
 entity_id: light.flur_nachtlicht
 data:
 brightness: 30

The condition is key: The night light only activates when the status is “Night”!

The Main Light Automation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


alias: Flur Hauptlicht bei Bewegung
trigger:
 - platform: state
 entity_id: binary_sensor.bewegungsmelder_flur
 to: 'on'
condition:
 - condition: not
 conditions:
 - condition: state
 entity_id: input_select.smart_home_status
 state: 'Nacht'
action:
 - service: light.turn_on
 target:
 entity_id: light.flur_hauptlicht

Here the condition is reversed: The main light only turns on when the status is not “Night”!

This is how I avoid being blinded when I step into the hallway at night!

In the video you can see both automations live in action!

The Bathroom Has Night Mode Too

I’ve applied the same principle in the bathroom as well:

At night: Dimmed night light (around 20% brightness)
During the day: Full brightness

This gives me a safe path from bed to bathroom and back, gently lit whenever the status is “Night”.

It makes those midnight bathroom trips so much more pleasant!

Why Not Just Use a Time Condition?

Good question! You could simply say: “Between 10 PM and 6 AM, use dimmed lighting.”

But: What if you stay up late on the weekend? Or go to bed early because you’re sick? Or get up at 3 AM and can’t fall back asleep?

With the status-based approach none of that is a problem:

✅ Adapts flexibly to your actual sleep schedule
✅ No rigid time window
✅ Manual override possible (press the button even if it’s only 9 PM)

In the video I explain why the status approach beats time conditions!

Morning: Alarm Cancels Night Status

When my alarm goes off in the morning, the “Night” state is automatically lifted:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


alias: Wecker - Status auf Anwesend
trigger:
 - platform: time
 at: input_datetime.wecker_time
action:
 - service: input_select.select_option
 target:
 entity_id: input_select.smart_home_status
 data:
 option: 'Anwesend'

The entire smart home wakes up!

When I then step into the hallway I get an appropriately wake-you-up light – no longer the dimmed night light, but full brightness.

Perfect for starting the day!

More Use Cases for the Status

The Smart Home status isn’t just useful for night mode! Here are a few more ideas:

Status “Away”

When nobody is home:

🚫 Turn down the heating
🚫 No motion-triggered lights
✅ Activate presence simulation
✅ Arm the alarm

Status “Vacation”

Extended absence:

🌅 Blinds simulate a normal daily routine
💡 Lights turn on and off at “realistic” times
🌡️ Heating set to frost protection
📧 Important notifications via email instead of push

Additional Status Ideas

You can of course define your own states:

“Party mode” – Special lighting, music integration
“Sick” – Higher heating, blinds closed, more quiet
“Work” – Home office mode with notification silencing
“Movie” – Dim lights, optimize TV settings

The possibilities are endless!

How to Set Up the Status

Convinced and ready to set up your own Smart Home status? Here’s how:

Step 1: Create the Input Select Helper

Go to: Settings → Devices & Services → Helpers

Click “Add Helper” and choose “Dropdown”

Settings:

Name: Smart Home Status
Icon: mdi:home-assistant
Options:
- Anwesend
- Nacht
- Abwesend
- Urlaub

Save! You now have input_select.smart_home_status

Step 2: Create Status Automations

Create automations that set the status:

Activate night mode:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


alias: Nachtmodus aktivieren
trigger:
 - platform: event
 event_type: zha_event
 event_data:
 device_id: 'dein_zigbee_taster_id'
 command: single
action:
 - service: input_select.select_option
 target:
 entity_id: input_select.smart_home_status
 data:
 option: 'Nacht'

Wake up:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


alias: Aufwachen - Nachtmodus beenden
trigger:
 - platform: time
 at: '06:30:00'
action:
 - service: input_select.select_option
 target:
 entity_id: input_select.smart_home_status
 data:
 option: 'Anwesend'

Step 3: Use the Status as a Condition in Your Automations

Now you can use the status as a condition in all your automations:

1
2
3
4


condition:
 - condition: state
 entity_id: input_select.smart_home_status
 state: 'Nacht'

Done! You now have a working Smart Home status.

In the video I walk you through all the steps in detail!

Tips and Tricks

A few valuable tips from my experience:

Tip 1: Place the Status Prominently on Your Dashboard

The status should be clearly visible so you always know what state your smart home is in.

Recommendation: On the home page at the very top, as a badge or large tile.

Tip 2: Allow Manual Overrides

Sometimes you want to change the status manually. Make sure the dashboard element is not read-only!

Tip 3: Keep the History

Enable long-term statistics for the status helper so you can trace how your smart home behaves over time.

Tip 4: Logging for Debugging

During development: log all status changes:

1
2
3
4


- service: logbook.log
 data:
 name: Smart Home Status
 message: "Status gewechselt zu {{ states('input_select.smart_home_status') }}"

This lets you see in the logbook when and why the status changed.

In the video I go into these tips in more detail!

Avoiding Common Pitfalls

A few typical mistakes I made early on:

Mistake 1: Too Many States

I started with 8 different states. It quickly became unmanageable. 4–5 states are plenty!

Mistake 2: Forgetting to Reset the Status

If the status is stuck on “Night” and you forget to reset it in the morning, your automations will run incorrectly all day!

Solution: Multiple triggers for resetting (alarm, time, manual light control)

Mistake 3: No Fallback Logic

What happens if the button breaks? Always have a second way to set the status (e.g. dashboard, time-based backup trigger)

Conclusion: Maintaining a Status is Worth It!

There really is nothing more to it than that! A simple helper with 4 states, a few automations to set the status, and then conditions in your relevant automations.

But the impact is enormous:

✅ Simpler automations (fewer complex conditions)
✅ Better readability (clear what happens when)
✅ Centralized logic (change the status instead of dozens of automations)
✅ Flexibility (new automations reuse the same status)

A status is useful for many things – not just night mode!

Make sure to watch the full video – you’ll see everything in action and I go into even more depth there!

Your Experiences?

Do you use a Smart Home status?

Home Assistant A-Z: M is for MQTT – The Invisible Glue

Sun, 21 Dec 2025 00:00:00 +0000

Welcome to the A-Z Series: M is for MQTT

In today’s episode of our Home Assistant A-Z Series, we’re diving into a topic that works quietly in the background and yet is absolutely essential: MQTT! It’s the invisible glue that brings almost any device into your smart home. Without MQTT, my smart home would grind to a halt in many places – but why is that?

Today I’ll explain in simple terms (promise: no complicated technical jargon!) what MQTT is, why it matters so much, and how I’ve integrated 52 devices with it in my Home Assistant setup.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What Is MQTT? 30 Seconds of Theory, Jargon-Free

Let me explain MQTT so simply that anyone can understand it – even if you’re not deeply technical.

The Problem Without MQTT

Normally, Home Assistant has to talk directly to every device. That means:

Home Assistant needs to know how to control the device
What data the device sends
In what units the data arrives
What interface the device uses

For every single device, Home Assistant needs its own dedicated integration. That’s a lot of work and limits the number of supported devices.

The Solution: MQTT as a Middleman

MQTT steps in between and simplifies everything dramatically:

Home Assistant only needs to know how to read from an MQTT server
The device only needs to know how to post its data to MQTT
The MQTT Broker (server) mediates between the two

The Brilliant Advantage

This has a huge advantage:

✅ The device can support MQTT and doesn’t care whether you’re using Home Assistant, OpenHAB, or any other smart home solution

✅ Home Assistant doesn’t care which device you have – as long as it speaks MQTT

MQTT is therefore a supremely universal solution for integrating as many devices as possible into Home Assistant, without Home Assistant needing to explicitly support each device!

In the video, I explain this even more clearly with a diagram!

A Live Look: 52 Devices via MQTT in My Smart Home

Enough theory! Let’s look at a real smart home and see everything I’ve integrated with MQTT.

In my MQTT integration in Home Assistant, I can see: 52 devices connected via MQTT. That’s more than half of all my devices! Without MQTT, my smart home would be capable of considerably less.

Let’s look at some concrete examples:

Aqara Motion Sensors via Zigbee2MQTT

I have several Aqara motion sensors distributed throughout my smart home – in the hallway, bathroom, storage room, and other areas.

How are they integrated?

The sensors speak Zigbee (a wireless protocol)
I use Zigbee2MQTT – the universal gateway for Zigbee devices
Zigbee2MQTT translates Zigbee signals into MQTT messages
Home Assistant reads these MQTT messages

The brilliant part: Zigbee2MQTT supports hundreds of different Zigbee devices from a wide variety of manufacturers. Set it up once, and everything works through the same pipeline!

In the video you can see the motion sensors live in the dashboard!

Philips Hue Lights via Zigbee2MQTT

My Philips Hue lights also run via MQTT – likewise through Zigbee2MQTT!

Why not the official Philips Hue Bridge?

Good question! The Hue Bridge would certainly work too, but:

✅ With Zigbee2MQTT I skip the need for an extra bridge ✅ Everything runs through the same infrastructure (one Zigbee stick) ✅ Completely local – no Philips cloud required ✅ Cheaper (no expensive Hue Bridge needed)

Hue lights also speak Zigbee, so they can communicate with Zigbee2MQTT just as easily as the Aqara sensors!

Where I use Hue lights:

Bedroom (for the wake-up light)
Terrace (for evening lighting)

In the video I’ll show you what the Hue lights look like in the MQTT dashboard!

Sonoff Devices with TASMOTA Firmware

Another great example: Sonoff devices. These are smart relays and sensors – similar to Shelly modules.

My configuration:

I’ve flashed most of my Sonoff devices with TASMOTA firmware. This is an open-source, alternative firmware that:

✅ Works completely locally (no cloud)
✅ Natively supports MQTT
✅ Is far more flexible than the stock firmware
✅ Is more secure (open source, no backdoors)

The Sonoff devices communicate via Wi-Fi (not Zigbee!) and send their data directly to the MQTT Broker.

Examples in my setup:

Smart plugs
Relays for light control
Temperature sensors

In the video I go into more detail on TASMOTA and show you what the devices look like!

Xiaomi Light Sensors for Automations

I have two Xiaomi light sensors mounted on the outside of the building. They continuously measure brightness and help me with various automations.

What I use them for:

Automatic lighting (e.g., terrace lights at dusk)
Blind control (automatically closing when the sun is intense)
Energy management (cloud cover = lower PV output)

These sensors also speak Zigbee and run via Zigbee2MQTT through MQTT into Home Assistant.

In the video I show you the live sensor readings!

Wallbox via EVCC

A particularly cool example: my wallbox for the EV is also integrated via MQTT!

How does that work?

I use EVCC (Electric Vehicle Charge Controller) – intelligent software for managing the wallbox. EVCC can:

PV surplus charging (only charge when the solar system produces enough power)
Use dynamic electricity prices (charge when power is cheap)
Monitor all values (charging power, battery level, costs)

EVCC publishes all these values to MQTT, making them available in Home Assistant.

What I get via MQTT:

Current charging power (in kW)
Total energy meter (total amount charged)
Current charging price (for dynamic tariffs)
Grid price and electricity rates
EV state of charge (in %)

All this data can be used in automations or displayed on dashboards!

More on EVCC is available in my dedicated video – link in the video and description above!

In the video I show you the wallbox entities live in the MQTT dashboard!

Why MQTT Is So Important

After all these examples, it’s clear: MQTT is the backbone of my smart home!

The Advantages at a Glance

Universal: Almost any device can speak MQTT
Vendor-independent: Whether Aqara, Philips, Sonoff, or Xiaomi – they all use MQTT
Protocol-agnostic: Zigbee, Wi-Fi, even Ethernet – everything ends up at MQTT
Future-proof: New device? If it speaks MQTT, it works
Local: No cloud required, everything stays on your own network

In the video I go even deeper into these advantages!

Installation: How to Get MQTT Into Home Assistant

Convinced and ready to use MQTT? No problem – the installation is surprisingly easy!

Option 1: Home Assistant OS (recommended for beginners)

If you’re running Home Assistant OS, MQTT is just one click away:

Step 1: Go to Settings → Add-ons

Step 2: Search for “Mosquitto broker” (this is the MQTT server)

Step 3: Install the add-on and start it

Step 4: Home Assistant automatically detects the Broker and suggests the integration

That’s it! No complex configuration needed. The Broker is running and ready to use immediately.

Option 2: Home Assistant Core / Docker

If you run Home Assistant Core and manage everything via Docker, you can start the Mosquitto Broker as a separate container:

Docker Compose example:

1
2
3
4
5
6
7


mosquitto:
 image: eclipse-mosquitto:latest
 ports:
 - "1883:1883"
 volumes:
 - ./mosquitto/config:/mosquitto/config
 - ./mosquitto/data:/mosquitto/data

Then add the MQTT integration in Home Assistant and provide the IP address and port (1883) of the Mosquitto container.

In the video I show you both installation methods!

Configuration: Almost None Required!

The beauty of MQTT: it requires almost no configuration!

The default port (1883) works out of the box
No complex settings
Ready to use immediately

Of course, for added security you can also:

Set up a username and password
Enable TLS encryption
Configure Access Control Lists (ACLs)

But for getting started, the default configuration is perfectly sufficient!

Connecting Devices to MQTT

You now have an MQTT Broker running – but how do devices connect to it?

Zigbee Devices: Zigbee2MQTT

For all Zigbee devices, I recommend Zigbee2MQTT:

What you need:

A Zigbee USB stick (e.g., ConBee II, Sonoff Zigbee 3.0)
The Zigbee2MQTT software (as an add-on or Docker container)

Setup:

Plug in the Zigbee stick
Install Zigbee2MQTT
Enter the MQTT Broker details (usually done automatically)
Pair devices (put them into pairing mode)

Done! All Zigbee devices appear automatically in Home Assistant.

Wi-Fi Devices: Native MQTT Support or TASMOTA

Some devices (e.g., Shelly, ESPHome devices) natively support MQTT. Simply enter the MQTT Broker IP in their settings – done!

Other devices (e.g., Sonoff) can be flashed with TASMOTA and then have MQTT enabled.

In the video I walk through concrete examples!

Software Integrations: EVCC and Others

Many software tools like EVCC can publish their data to MQTT. In the respective configuration, you enable MQTT and provide the Broker details – and the data flows straight into Home Assistant!

Creative Use Cases for MQTT

Beyond plain device data, you can also use MQTT for creative purposes:

Build Your Own Sensors

With ESPHome or TASMOTA you can build custom sensors and integrate them via MQTT:

Temperature and humidity sensors in the garden
Water level sensors for plants or cisterns
Door contacts in unusual locations
PIR sensors for motion detection

Exchange Data Between Systems

MQTT is perfect for sharing data between different systems:

Home Assistant → Node-RED → MQTT
MQTT → Grafana (for beautiful dashboards)
MQTT → InfluxDB (for long-term data analysis)

Trigger External Automations

You can trigger external tools via MQTT messages:

Start the 3D printer when the solar system has enough surplus
Activate the irrigation system when soil moisture is low
Arm security systems based on presence

The possibilities are endless!

Pitfalls and Tips

To wrap up, here are a few important tips from my own experience:

Tip 1: Plan Your Topic Structure Early

MQTT uses Topics for organization. Think through a sensible hierarchy from the start:

1
2
3


home/living-room/temperature
home/living-room/humidity
home/bedroom/temperature

Not:

1
2
3


temp_living-room
humidity_living-room
temperature_bedroom

A clear structure will save you a lot of headaches later!

Tip 2: Use Retained Messages

For status values, you should enable Retained Messages. This way the Broker stores the last known value – even if a client restarts.

Tip 3: Understand Quality of Service (QoS)

MQTT defines three QoS levels:

QoS 0: Fire and forget (fast, but unreliable)
QoS 1: Delivered at least once
QoS 2: Delivered exactly once

For smart home purposes, QoS 1 is usually sufficient.

Tip 4: Use Discovery

Many tools (e.g., Zigbee2MQTT, TASMOTA) support MQTT Discovery. This means devices register themselves automatically with Home Assistant – no manual configuration needed!

In the video I go into these tips in more detail!

Conclusion: MQTT Is Indispensable

After all of this, it’s clear: MQTT is absolutely indispensable for my smart home!

What I wouldn’t have without MQTT:

52 fewer devices
No Zigbee devices
No flexible wallbox integration
Far fewer options for custom projects

MQTT makes a smart home flexible, open, and future-proof. It’s one of the reasons I value Home Assistant so highly!

Make sure to watch the video – there you’ll see everything in action live!

Your Experiences?

What do you integrate with MQTT?

Let me know in the comments:

Which devices do you use over MQTT?
Do you have creative use cases?
Are you using Zigbee2MQTT or other gateways?
What questions do you have about MQTT?

Home Assistant A-Z: L is for Light – Simple to Creative

Sun, 14 Dec 2025 00:00:00 +0000

Welcome to the A-Z Series: L is for Light

In today’s episode of the Home Assistant A-Z Series we’re tackling the absolute classic for beginners: light! For many people, their first lighting automation is the magical moment when an idea becomes a real smart home. But there’s so much more to it than just on and off!

Today I’ll show you how I use light in my smart home – from simple motion-sensor automations to gentle wake-up lights and creative visual reminders. Let yourself be inspired!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

How I Control My Lights: The Hardware

Before we get to the exciting automations, let me show you which hardware I use for my lighting control. Spoiler: it’s a colourful mix – and that’s exactly what makes Home Assistant so flexible!

Shelly Modules: The In-Wall Solution

The bulk of my lighting runs through Shelly modules (e.g. the Shelly Plus 1 PM* – also at OBI* or directly at Shelly* (code SMARTHOMEABERSICHER-10OFF for 10% off)) that I’ve fitted behind existing wall switches. There are several advantages:

✅ The existing wall switch still works
✅ Additional control via Home Assistant
✅ Completely local, no cloud required
✅ Affordable retrofit for existing lamps

In my home these cover, among others:

Guest bathroom
Hallway
Bathroom
Dressing room
Storage room

The Shellys are integrated directly into Home Assistant via the Shelly integration and respond instantly – whether I use the physical switch or trigger an automation.

In the video I show you exactly what that looks like in the dashboard!

Philips Hue: Colour and Flexibility

I also have some Philips Hue lights in use, which I control via Zigbee2MQTT. The advantage: no Philips Hue Bridge needed – everything runs through my Zigbee stick!

Where I use Philips Hue:

Bedroom – for the gentle wake-up light (more on that in a moment!)
Terrace – for atmospheric evening lighting

Depending on the model, Hue lights can:

Change white tones (from cool white to warm white)
Display full RGB colours
Dim softly over long periods

In the video you’ll see the difference between the various Hue models live in the dashboard!

ESPHome LED Strip: The DIY Project

My personal highlight is a custom-built LED lamp in the hallway, made from an LED strip with individually addressable LEDs. Control is handled by an ESP32 microcontroller running ESPHome.

What makes it special: the lamp consists of several rings that I can address individually with different colours. I use this for creative automations – more on that shortly!

Make sure to watch the lamp in action in the video – the effects are impressive!

What Can I Do With the Different Lights?

Now it gets interesting: what are the possibilities of the different light types?

Shelly: Simple but Reliable

The Shelly-controlled lights are the simplest in my setup. They can:

✅ Switch on and off

Sounds underwhelming? It is – but that’s exactly what makes them so reliable and fast. For rooms like the bathroom, hallway, or storage room, I don’t need anything more. The main thing is that the light comes on when I need it!

Philips Hue: The Colour Artists

With the Hue lights things get considerably more interesting. Depending on the model they can:

Warm white / cool white lights:

Change colour temperature (from cosy warm white to energising cool white)
Dim brightness continuously
Smooth transitions over minutes or even hours

RGB lights:

Display any colour in the RGB spectrum
Colour-change animations
Combinations of colour and brightness

In the video I show you both variants live in the dashboard – the difference is striking!

ESPHome LED Strip: The All-Rounder

My custom-built LED lamp can do everything Hue can – and more:

Full RGB display for every individual LED
Individual control of separate rings with different colours
Special effects such as running lights, rainbow, or pulsing
Dynamic displays for smart home status

I use this flexibility for the most creative automations – more on that shortly!

The Interesting Automations

Now for the exciting part: what do I actually do with all these lights? Here are my favourite automations!

Motion Sensor + Shelly: The Classic

The simplest and simultaneously most useful automation: light comes on automatically when I enter a room.

How does it work?

Motion sensors distributed throughout the rooms
Trigger: Motion detected
Action: Switch on Shelly light
Timeout: Automatically switch off after X minutes without motion

Where I use this:

Hallway
Storage room
Dressing room
Guest bathroom

Sounds trivial, but it’s incredibly practical! You come in from the car with your hands full and don’t have to feel for a light switch. The light is simply already on.

In the video I show you the automation and how it responds live!

Wake-Up Light: A Gentle Start to the Day

This is where it gets more interesting: my Philips Hue lights in the bedroom serve as a gentle wake-up light.

The problem: A normal alarm clock tears you brutally out of sleep. With light, it’s so much gentler!

How I implement it:

Trigger: Wake-up time (weekdays only)
Action: Gradually dim lights up over 20 minutes
Starting point: Very warm, dimmed light (simulates morning sun)
End point: Bright, cooler light (gently wakes you up)

The trick: Home Assistant can slowly brighten lights using a transition parameter. This means the light continuously changes brightness and colour temperature over 20 minutes!

Additional feature: At the same time I also switch on the radio and slowly increase the volume. The perfect start to the day!

Make sure to look at the automation code in the video – I’ll show you the transition parameter!

I use the custom-built LED lamp in the hallway as an intelligent night light:

The idea: When someone needs to use the bathroom at night, the hallway should be subtly lit – but not so bright that you’re fully awake.

How it works:

Motion sensor detects movement in the hallway
Condition: It is between 22:00 and 06:00
Action: LED lamp switches on with very low brightness and warm light
Timeout: Automatically switches off after 2 minutes

The brilliant part: the lamp is bright enough to navigate by, but not so harsh that it wakes you up completely. The perfect compromise!

Bin-Day Reminder: Never Forget Visually Again

Now it gets really creative: I use the individually addressable rings of my LED lamp as a visual reminder for bin collection!

The problem: I regularly forget to put the bin out in time.

The solution: The lamp shows me in colour which bin is being collected tomorrow!

How it works:

Trigger: Afternoon at 16:00
Condition: Check whether a bin is being collected tomorrow
Action: Show a coloured ring on the LED lamp
- 🟢 Green = Food/garden waste bin
- 🟡 Yellow = Recycling/yellow bag
- 🔵 Blue = Paper bin
- ⚫ Black = General waste

Every time I walk through the hallway I see the coloured ring and am reminded. Better than any push notification!

In the video I show you the complete automation and what the lamp looks like when multiple bins need to go out at the same time!

By the way: how I integrate bin collection schedules into Home Assistant is covered in a dedicated article about the bin collection integration. Definitely check it out if you’re interested in that topic!

More Creative Ideas for Light in Home Assistant

You can see: light is so much more than just on and off! Here are a few more ideas I haven’t implemented myself, but which might be interesting for you:

Presence Simulation While on Holiday

Use your smart lights to simulate presence when you’re away:

Lights come on and go off at random times
Different rooms are lit in sequence
Timings oriented around realistic patterns (living room in the evening, bedroom at night)

Alarm Visualisation

If movement is detected in the garden or a window opens while you’re away, lights can:

Flash red as a warning
Alert you acoustically and visually
Act as a deterrent to intruders

Mood Modes

Create different scenes for different situations:

🎬 Movie mode: Dimmed, warm light
🍽️ Dinner mode: Bright, cosy light over the dining table
🎉 Party mode: Colourful colour changes
📚 Reading mode: Bright, neutral white light

Daylight Adaptation

Automatically adjust the colour temperature of your lights to the time of day:

Morning: Cool, energising light
Midday: Neutral white
Evening: Warm, relaxing light (supports your natural sleep rhythm)

Why Light Is the Perfect Entry Point into Home Assistant

If you’re new to Home Assistant: light is the ideal starting point!

Reasons:

Immediate feedback – you see straight away whether your automation is working
Not critical infrastructure – if something goes wrong, it’s not a disaster
Many hardware options – from affordable (Shelly) to comfortable (Hue)
Simple automations – perfect for learning the basics
Plenty of room for creativity – once the basics are in place, you can experiment

In the video I give you even more tips for beginners!

Hardware Recommendations

Want to get started smart? Here are my hardware recommendations based on my own experience:

For Wall Switches: Shelly

Shelly 1 or Shelly 1PM for simple on/off lights
Works with existing switches
Completely locally controllable
Affordable to purchase

For Colour and Comfort: Philips Hue

Zigbee2MQTT instead of a Hue Bridge (saves money and increases flexibility)
White Ambiance for colour temperature control
White and Colour for full RGB control

For Makers: ESPHome

WLED-compatible LED strips with WS2812B LEDs
ESP32 or ESP8266 as controller
ESPHome for easy integration into Home Assistant

Affiliate links to recommended hardware can be found in the video description!

Avoiding Common Pitfalls

From my experience there are a few typical mistakes when getting started with lighting control:

Mistake 1: Too Many Automations for One Light

When multiple automations control the same light, they can conflict with each other. Example: a motion sensor switches the light on, but at the same time another automation wants to switch it off.

Solution: Use conditions in your automations or central logic helpers.

Mistake 2: No Manual Override

It’s annoying when an automation switches the light off while you’re still in the room!

Solution: Build in manual override options, for example via an Input Boolean.

Mistake 3: Motion Sensor in the Wrong Spot

A poorly positioned motion sensor detects you too late – the light stays off.

Solution: Test different positions and pay attention to the detection range of your sensor.

In the video I go into these pitfalls in more detail!

Watch the Video!

I’ve told you a lot, but you’ll understand it best when you see it! In the video I show you:

✅ All lights live in the dashboard
✅ The automations in detail
✅ The custom-built LED lamp in action
✅ What the bin-day reminders look like
✅ The code for the wake-up light

Click the video above and watch it now!

Further Articles and Videos

If you’re interested in the topic of lights and automations:

Never forget the bins again – How I use the bin collection integration
Installing Shelly roller blinds – If you want to learn more about Shelly modules
Blueprints – How to easily import automations

The complete A-Z Series can be found here: Home Assistant A-Z Overview

Home Assistant A-Z: K is for AI – Does AI Belong?

Sun, 07 Dec 2025 00:00:00 +0000

Welcome to the A-Z Series: K is for AI

In today’s episode of our Home Assistant A-Z Series, we tackle a controversial topic: Artificial Intelligence in your Smart Home! AI is everywhere right now – but does it really align with the core principles of Home Assistant? Today I give you 10 reasons why AI actually doesn’t belong in Home Assistant – and at the end I’ll still tell you where AI can make sense.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The Uncomfortable Truth About AI in Smart Home

Artificial intelligence is the buzzword of the moment. Every manufacturer advertises it, every app wants to be “intelligent.” But let’s be honest: Does your Smart Home really need AI? Or is it just marketing?

Home Assistant was built with clear values: Local control, privacy, independence, and reliability. And this is exactly where the problem with AI models begins. In the video I show you why these two worlds actually don’t fit together – and why that’s actually a good thing!

Reason 1: Cloud Dependency vs. Local Control

The foundation of Home Assistant is local control. Your data stays with you, your system works even without internet. This is one of the main reasons many of us switched to Home Assistant in the first place!

AI models, on the other hand? They run almost always on external cloud servers. Why? Because they need enormous computing power. That’s the complete opposite of what makes Home Assistant special.

In the video I explain why this cloud dependency is not just a philosophical problem, but has real practical disadvantages.

Reason 2: Unpredictability – Smart Homes Need Determinism

Imagine: You come home and sometimes the lights turn on, sometimes not. Or the heating decides today that it’s not that cold after all. Sounds absurd? That’s exactly what happens when you let AI run unchecked in your Smart Home!

AI always works with probabilities. “With 87% probability the mail carrier is at the door” – fine for a notification. But for critical automations? Absolutely not!

When It’s Cold, the Heating Must Come On

A classic example from the video: When the temperature drops below 19 degrees, the heating should kick in. Period. No discussion.

You don’t want an AI model “thinking” about whether it currently makes sense to turn on the heating. You’re cold right now – there’s no time for probability calculations!

Watch the video to see where this difference between deterministic rules and AI probabilities really becomes critical!

Reason 3: Explainability Is Completely Missing

With a classic automation you can precisely trace what happened:

You look at the traces
You see which conditions were met
You find the error and fix it

With AI you only get: “The model decided it was A.” Why? No idea. What can you change? Unclear.

Classic debugging as in software development is simply impossible. In the video I show you why this is a massive problem for the maintainability of your Smart Home.

Reason 4: Hallucinations Are Fatal in Smart Homes

You’ve surely heard of “hallucinations” in AI models – when the AI makes up things that don’t exist. This is an inherent property of AI and cannot be completely eliminated.

AI Cannot Say “I Don’t Know”

AI models have an extremely hard time admitting they don’t know something. Present them with a choice between A or B, and a decision will be made – even if the underlying data isn’t there at all.

In your Smart Home, this can have fatal consequences. In the video I give you concrete examples of where such hallucinations can become truly dangerous.

Reason 5: AI Is in Constant Flux

What works today with a particular AI model may be completely different tomorrow with the next version. AI models are in an extremely fast development cycle.

You’ve set up your automations perfectly, everything’s running? Then the next AI model update comes along and turns everything upside down. That’s the opposite of what a Smart Home should be – stable, reliable, low-maintenance.

In the video I explain why this constant change turns your Smart Home into a perpetual work-in-progress!

Reason 6: Computing Power – Local or Cloud?

If you want to run AI locally (which would actually be the only Home Assistant-compatible option), you need massive computing power.

Most of us run Home Assistant on a Raspberry Pi or similarly lightweight hardware. That’s enough for hundreds of automations – but not for compute-intensive AI models.

So back to the cloud? Then we’re back at Reason 1: cloud dependency. A vicious cycle!

Watch the video to see what hardware you’d really need for local AI – the numbers are sobering!

Reason 8: Privacy – Your Private Life

Yes, Reason 7 is missing from the transcript – probably a small mistake during recording! But Reason 8 is all the more important: Privacy!

Smart Home data is extremely private:

Camera images show your home and your family
Presence data reveals when you’re home and when you’re not
Sensor data shows your habits in the finest detail

Should this intimate information really end up in a cloud AI? Absolutely not!

In the video I explain why Smart Home data in particular is so sensitive and why you should be very careful about who you trust with this data.

Reason 9: Home Assistant Already Has Everything

Let’s be honest: Look at the list of integrations! Over 3,000 integrations, countless sensors, helpers, template functions – Home Assistant can already do just about everything.

What You Really Need

You can derive precise decisions from your sensors:

Motion sensors tell you if someone is home
Bluetooth beacons track your devices
Temperature sensors control the heating
Brightness sensors regulate the lighting

All of this deterministic, reliable, and with the precision you define in your automations.

In the video I show you that the real use cases for AI in Home Assistant can be counted on one hand!

Reason 10: AI Solves Problems You Can Solve Differently

The last reason is perhaps the most important: Do you really need AI for these problems?

Example 1: Presence Detection

Do you need AI to detect if someone is home? No!

Motion sensors in every room
Bluetooth beacons from smartphone or watch
Door sensors

All of this gives you deterministic, reliable presence detection – completely without AI!

Example 2: Heating Control

Do you need AI-powered heating control to squeeze out the last percent of optimization? Or would a simple day and night temperature be completely sufficient?

The answer is almost always: The simple solution is enough! In the video I give you more examples where AI seems complicated but the solution is actually simple.

But: AI Can Still Help!

After all the critical points, I promised: There are actually sensible use cases for AI in Home Assistant! Just not where most people expect them.

Use Case 1: Analyzing Log Files

Who doesn’t know this? Home Assistant floods you with log files, and you desperately ask yourself: “What’s actually going wrong here?”

AI models or language models are perfect for processing large amounts of text.

Simply copy the log files into ChatGPT or another language model and ask: “What’s the problem here?” Even if a direct solution doesn’t always come out, you at least get ideas for further research.

In the video I show you how this works in practice and which prompts work well!

Use Case 2: Debugging Jinja Templates

You’ve gotten tangled up in Jinja templates again and are completely at a loss as to why it’s not working?

Copy the template snippet into an AI and let it analyze it. The chances are good that you’ll get valuable tips on where the error lies.

This is, by the way, one of my personal main use cases for AI: understanding and debugging complex template syntax!

Use Case 3: Object Detection

The third sensible use case: Object detection in camera images.

“Is that the mail carrier at the door or the neighbor?” – this is actually a legitimate use case for AI (or more precisely: for machine learning).

Important distinction: Here we’re talking less about language models, but rather classical machine learning for image recognition. In the video I explain the difference and why it actually makes sense here.

Conclusion: AI Doesn’t Replace Logic

After all these arguments, the conclusion can be stated very clearly:

AI doesn’t replace logic in Home Assistant. At best, it can help build it better.

Home Assistant thrives on:

Deterministic rules
Local control
Privacy
Reliability

And these are exactly the values you should not sacrifice for the AI buzzword. Use AI where it truly adds value – in debugging, in development, in specific recognition tasks. But build your Smart Home on solid, transparent automations.

Make sure to watch the complete video – I go even deeper into each argument and show you practical examples!

What’s your take on AI in your Smart Home?

Write in the comments:

Are you already using AI features in Home Assistant?
Did I convince you, or do you see other sensible use cases?
Where would you like AI support?

Charge Your EV Without Cloud: EVCC Controls the Wallbox

Sun, 30 Nov 2025 00:00:00 +0000

The Problem: Wallbox Apps That Drive You Crazy

You have an EV and a wallbox, but you’re frustrated with clunky manufacturer apps and terrible smart home integration? The app is slow, confusing, and sends all your data to the cloud?

There’s a better way! With EVCC, you get a fully local solution for intelligent control of your EV charging – no cloud, no dependency, maximum control.

In the new video, I’ll show you my complete setup and how I saved over €2,500 with it!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What Is EVCC?

EVCC stands for “Electric Vehicle Charge Controller” and is an open-source software for intelligent wallbox control. What makes it special:

✅ Completely local – no cloud connection required
✅ Open source – transparent code, active community
✅ Manufacturer-independent – works with almost any wallbox
✅ Professional UI – more polished than any manufacturer app
✅ Smart Home integration – works perfectly with Home Assistant & more

With or Without a PV System

The brilliant part: EVCC works with AND without a PV system!

With PV: Intelligent surplus charging – make the most of your solar energy
Without PV: Charge on a schedule or with dynamic electricity prices

In the video, I’ll show you both scenarios!

My Setup in Detail

In my setup, I use:

PV system on the roof (optional!)
Home battery storage in the basement (optional!)
Wallbox in the garage (required)
EV (hopefully you have one 😊)
Raspberry Pi 4 running EVCC as a Docker container

My wallbox is connected to the Raspberry Pi via a Modbus cable (20 meters through the basement!). But don’t worry: depending on the wallbox model, this can also work over Wi-Fi or Ethernet.

The best part: You don’t need my complete setup! A single wallbox is enough to get started.

In the video, I’ll show you my complete installation including the wiring!

The EVCC Dashboard: A Dream!

Does this brilliant user interface look like a “hacky” open-source tool to you? I was completely blown away when I first launched it!

What You See at a Glance:

Top: Energy flows

Where is the power coming from? (PV, battery, grid)
Where is it going? (house, car, battery, grid)
Live updates every 10 seconds

Middle: Charging modes

PV: Surplus charging – solar power only
Min+PV: Minimum load + solar
Fast: Full power – regardless of source

Bottom: Details

Current charging power
Battery state of charge
Estimated charging time
Cost overview

Make sure to watch the video to see the display change in real time!

Live Demo: How Surplus Charging Works

In the video, I’ll walk you through three live scenarios:

Scenario 1: No Sun, No Car

PV system produces little (November fog)
Home battery covers household consumption
No charging possible

Scenario 2: Lots of Sun, No Car

PV system produces a decent amount
Home battery is full
Surplus is exported to the grid (wasted)

Scenario 3: Sun + Car Plugged In 🎉

PV system is producing
Household consumption is covered
Surplus flows into the car!
EVCC adjusts automatically every 10 seconds

The dynamic adjustment is impressive – check it out in the video!

Dynamic Electricity Prices: Saving Money on Autopilot

For me, this is the killer feature: EVCC supports dynamic electricity prices!

How It Works:

Create a charging plan
- When do you need the car? (departure time)
- How full should it be? (target state of charge)
EVCC automatically calculates
- When is electricity cheapest?
- How long does charging take?
- What will it likely cost?
Car charges automatically at the best time
- No manual intervention needed
- Maximum savings
- Ready on time for departure

In the video, I’ll show you the charging plan in action!

My Experience With Tibber

I used Tibber for two years – essentially the pioneer of dynamic electricity tariffs in Germany. I’m no longer a Tibber customer these days, but the principle works with any provider that offers dynamic tariffs.

What Made Tibber Special

✅ Price changes every 15 minutes
✅ No smart meter required – works with a standard meter
✅ Perfect EVCC integration
✅ Transparent pricing

Making Use of Price Dynamics

In the video, I’ll show you the Tibber app:

You can see the price curve for the next 24 hours. The dynamics are impressive:

🟢 Cheap times: Often at night, when there’s a lot of wind/solar on the grid
🔴 Expensive times: Usually in the evening during peak grid load

EVCC automatically charges during the green phases!

The Result: €2,500 Saved!

EVCC logs all charging sessions and calculates your savings. In my case, it’s now over €2,500 euros!

Installation: Easier Than You Think

EVCC runs as a Docker container on a Raspberry Pi 4 at my place. The installation is surprisingly straightforward:

Option 1: Docker (My Choice)

1
2
3
4
5
6


# Download and start the container
docker run -d \
 --name evcc \
 -p 7070:7070 \
 -v $(pwd)/evcc.yaml:/etc/evcc.yaml \
 evcc/evcc:latest

Advantages:

✅ Quick to set up
✅ Other services can run in parallel
✅ Easy updates

Option 2: Home Assistant Add-on

If you’re using Home Assistant OS, there’s an official add-on!

Installation:

Open the Add-on Store
Search for “EVCC”
Install & start

Even easier than Docker!

In the video, I’ll show you both options!

Configuration: YAML or Web UI

For initial configuration, you have two paths:

Classic: YAML File

This is how I did it. You edit a text file:

1
2
3
4
5
6
7
8
9


site:
 title: My EVCC
 meters:
 grid: ...
 pv: ...

chargers:
 - name: Garage Wallbox
 type: ...

For: Tinkerers who enjoy writing code Against: Slightly steeper learning curve

Modern: Web UI

Since a few versions back, there’s a graphical configuration interface!

For: Beginners who prefer simplicity Against: (None, really 😊)

In the video, I’ll show you the Web UI – super intuitive!

Wallbox Compatibility: A Huge Selection

My wallbox is connected via Modbus cable. But EVCC supports an incredibly wide range of wallboxes:

Supported Connection Types:

Modbus (my setup)
Wi-Fi
Ethernet
Cloud (if necessary)

Supported Manufacturers:

The list is impressively long:

ABL
EVSE WiFi
go-eCharger
KEBA
Mennekes
Phoenix Contact
Wallbe
… and many, many more!

Check the EVCC documentation – I haven’t found a wallbox yet that isn’t supported!

Link to the full list in the video and description!

Manufacturer Independence: The Big Advantage

What makes EVCC truly special: you can mix and match manufacturers freely!

In my setup:

Wallbox: Manufacturer A
PV inverter: Manufacturer B
Home battery storage: Manufacturer C (added just recently!)

All from different manufacturers who normally don’t work together. With EVCC? No problem!

In the video, I’ll tell you how seamlessly my new home battery storage was integrated!

5 Reasons Why EVCC Impresses Me

1. Completely Local

No cloud, no dependencies. Your data stays with you. Even during an internet outage, local control keeps working!

2. Open Source With a Professional UI

The code is public, the community is active. But the user interface looks like it came from a professional team!

3. Massive Hardware Support

Almost every wallbox, almost every inverter, almost every EV is supported. The community keeps growing.

4. Intelligent Charging Control

With a PV system and/or dynamic electricity prices, you save real money. In my case: over €2,500!

5. Manufacturer Independence

You’re not locked in. Switching wallbox? No problem. New battery storage? Works!

Even my in-laws are now using EVCC – and without any issues!

Who Is EVCC For?

✅ Perfect if you:

Have an EV and a wallbox
Want control over your data
Like saving money (PV or dynamic tariffs)
Are familiar with Raspberry Pi or Home Assistant
Value manufacturer independence

⚠️ Less suitable if you:

Have no technical interest
Need everything “out of the box”
Have no time for setup

But honestly: The setup is easier than you’d think!

Frequently Asked Questions

“Do I need a PV system?”

No! EVCC works without one too. You can:

Charge on a schedule
Use dynamic electricity prices
Simply enjoy the better UI

“Does my wallbox work with it?”

Very likely! Check: https://docs.evcc.io/docs/devices/chargers

The list is impressive. In the video, I’ll show you where to look!

“Is the installation complicated?”

No! If you’ve used Docker or Home Assistant before, it’s a breeze.

“How much does EVCC cost?”

EVCC is free! Open source, no license fees. You only pay for the hardware (Raspberry Pi, wallbox).

Your Path to EVCC

Step 1: Check your hardware

Do you have a supported wallbox?
Do you have a Raspberry Pi or NAS?

Step 2: Installation

Docker or Home Assistant add-on
Download and start EVCC

Step 3: Configuration

Connect the wallbox
Optional: PV system, battery storage, electricity meter

Step 4: Enjoy!

Open the dashboard
Try out the charging modes
Save money 😊

I’ll walk you through all the steps in detail in the video!

Your Experiences?

Write me in the comments:

How do you charge your EV at home?
Are you already using EVCC?
Did I spark your curiosity?
Which wallbox do you have?

Be sure to watch the video – there you’ll see the dashboard live, the charging modes in action, and my complete installation!

Home Assistant A-Z: J is for Blinds

Sun, 23 Nov 2025 00:00:00 +0000

Welcome to the A-Z Series: J is for Blinds

In today’s episode of the Home Assistant A-Z Series we tackle a topic with far more potential than most people realize: blinds and roller shutters! From elegant dashboard control and time-based automations to fully automatic, sun-dependent shading – I’ll show you how to make your home more energy-efficient and comfortable.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

More Than Just Up and Down

Most people use their smart roller shutters only for the basics. But there’s so much more potential hiding in them! In this article and the accompanying video I’ll walk you through:

Dashboard control with live feedback
Time-based and event-driven automations
Groups and template sensors for a quick overview
Fully automatic, sun-dependent shading
Seasonal adjustments to your setup

Dashboard Control: The Foundation

The first step toward smart roller shutters is intuitive control through your dashboard.

Position Control with Live Feedback

If your roller shutters can report their position back, you can see in Home Assistant not just the current status, but also:

Move to precise intermediate positions using a slider
Watch live as the shutter reaches the desired position
Use classic Open/Close/Stop controls on a secondary level

In the video you’ll see how elegant this looks in practice!

Visualization on Floor Plans

Things get especially clear when you project your roller shutters onto a floor plan of your home. At a glance you can see:

Which shutters are open
Which are currently closing
The status of all windows at the same time

Under the hood: A simple picture-elements card with positioned shutter controls. I show you exactly how this works in the video!

Time-Based Automations: The Smart Home Classic

Constantly tapping buttons isn’t smart – so let’s automate!

Automation 1: Close Automatically at Night

The first useful automation makes sure roller shutters are closed at night. You can use various triggers:

State-based: When you go to bed (Smart Home state “Night”)
Time-based: At a specific time (different for weekdays and weekends)
Condition-driven: Only when it’s cool outside (to make use of the insulating effect)

In the video I show you concrete examples from my own setup!

Automation 2: Open Automatically in the Morning

Symmetrically, when you get up in the morning the shutters open again automatically. Alternatively, you can use the sun’s position as a trigger.

Intelligent Schedules with Helpers

For different schedules (weekday vs. weekend) schedule helpers are perfect. You can define them as “quiet hours” and reference them in your automations.

Groups and Overview: Everything Under Control

Grouping Roller Shutters

You can create any groups of roller shutters you like – for example:

All shutters in the living room
All shutters on the south-facing side
All shutters in the entire house

With a single click you can then open or close all shutters in that group.

Template Sensor for an Overview

A small template sensor shows you on your dashboard how many roller shutters are currently closed:

1
2
3
4
5
6
7
8
9


sensor:
 - platform: template
 sensors:
 closed_covers_count:
 friendly_name: "Closed Roller Shutters"
 value_template: >
 {{ states.cover
 | selectattr('state', 'eq', 'closed')
 | list | count }}

This way you always have a clear overview! In the video you can see how I use this on my dashboard.

Automatic Shading: The Game Changer

Now things get really interesting: fully automatic, sun-dependent shading!

The Two Components

My system consists of two automation groups:

1. Sun Position Calculation per Facade

The first group calculates for each cardinal direction whether the sun is currently shining on that facade:

Blueprint-based: I use a blueprint that I’ve instantiated four times
One helper per facade: North, South, East, West
Dynamic calculation: Takes the current sun position into account

I cover the technical details and the blueprint thoroughly in the video!

2. Individual Control per Window

The second group controls each individual roller shutter:

One blueprint per shutter: Each shutter can be configured individually
Window contacts taken into account: Window open? Shutter stays up!
References the sun-position helpers: Only closes when the sun shines on that facade

Example from my setup: The roller shutter in the utility room on the north side closes as soon as the sun (even in summer, only at the edges of the day) shines on that facade.

Why One Automation per Window?

This approach enables maximum flexibility:

Each shutter can be individually enabled or disabled
Different rooms can be controlled differently
Seasonal adjustments are easy to make

Seasonal Configuration: Adapting Throughout the Year

The great thing about this system: you can adjust which rooms should be shaded as the seasons change.

My Scenarios

Winter (currently):

✅ All shading automations disabled
🌞 I enjoy every ray of sunshine that enters the apartment

Transition periods (spring/autumn):

✅ Only bedroom automations enabled
🏠 Rest of the apartment: sunshine welcome
😴 Bedroom: should stay cool

Midsummer:

✅ All shading automations enabled
❄️ Maximum cooling through consistent shading

On my dashboard I have an elegant overview where I can see at a glance which automations are active. I show you this view live in the video!

Hardware Basics

Wondering how to make your roller shutters smart in the first place?

In my Shelly roller shutter video I cover in detail:

Hardware selection (Shelly Plus 2PM, Shelly 2 Gen3 Or at OBI: Shelly 2 Gen3, Shelly 2 Gen4 Or at OBI: Shelly 2 Gen4, or directly at Shelly – code SMARTHOMEABERSICHER-10OFF for 10% off)
Wiring in the flush-mount box
Software setup and security
Home Assistant integration

👉 To the Shelly Blinds Video

The Blueprints in Detail

The blueprints for sun-position calculation and individual control are the core of my system.

Interested in the details? Let me know in the comments under the video! If there’s enough interest, I’ll make a bonus video dedicated to these blueprints, covering:

Complete code
Step-by-step explanation
Customization options
Download links

Practical Benefits in Everyday Life

What does this actually get you?

Comfort

Automatic adjustment to sunlight
Never need to manually intervene again
Smart Home thinks ahead – even when you’re not home

Energy Efficiency

Cooler rooms in summer through consistent shading
Warmer rooms in winter through the insulating effect at night
Less air conditioning/heating required

Security

Presence simulation while on vacation
Automatic closing during storms possible
Integration with alarm systems

Level 1 – Basics:

Add roller shutters to Home Assistant
Set up dashboard control
Create first time-based automations

Level 2 – Comfort: 4. Create groups 5. Add template sensors for overview 6. Visualize on floor plan

Level 3 – Pro: 7. Implement sun-position calculation 8. Set up individual shading automations 9. Configure seasonal adjustments

I walk you through every step in detail in the video!

Further Links

More helpful articles from the A-Z Series:

Hardware:

Shelly Blind Control

The Home Assistant A-Z Series brings you the most important Home Assistant concepts in short videos and in-depth articles. A new letter every Sunday, a little more knowledge each time!

Replace Your Tablet Battery Yourself in 20 Minutes

Sun, 16 Nov 2025 00:00:00 +0000

When Your Tablet Never Leaves the Charger

Sound familiar? Your tablet used to be great, but now the battery barely lasts a few hours. Maybe you use it for your Smart Home Dashboard in Home Assistant or for other purposes – but being permanently tethered to a cable is simply annoying.

Most people think: “Time for a new device.” But wait! These devices are far too good to throw away. In this article I’ll show you how to breathe new life into your tablet with a new battery – and without any special tools!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Why Repair It Yourself?

Sustainability and Resource Conservation

Every repaired device is a win for the environment. Manufacturing a new tablet consumes enormous resources – raw materials, energy, water. A new battery for €20–30 and 20 minutes of your time can extend the device’s life by years.

Save Money

A new tablet can easily cost several hundred euros. A replacement battery? About €20–30. The math is simple!

It’s Fun!

Honestly: there’s a really great feeling when the device works again after the repair. In the video you can watch every step live alongside me!

My Example: Samsung Galaxy Tab S3

For my Smart Home Dashboard I use a Samsung Galaxy Tab S3. It’s a bit older, but still perfect for Home Assistant. The battery, however, was completely done – the tablet only lasted a few hours.

Spoiler: After the battery replacement it now runs for a whole week again! 🎉

What You Need

Tools (no special equipment!)

Hair dryer (yes, really – your regular hair dryer!)
Suction cup or suction cup clamp (available at any hardware store)
Plastic spatula or an old credit/loyalty card
Small screwdriver (Phillips head)
Optional: Plastic opening tools (available online for a few euros)

Materials

Replacement battery matching your tablet model
Optional: Replacement adhesive strips for the housing

Important note on buying the battery:

⚠️ Do NOT buy the cheapest battery you find online!

Make sure to look for:

✅ Reputable distributors
✅ Good ratings and reviews
✅ Brand manufacturers or certified replacements

Why? Low-quality lithium-ion batteries don’t just perform poorly – in the worst case they can catch fire. Safety first! I cover this in detail in the video.

Step-by-Step Guide

Step 1: Warm Up the Housing with the Hair Dryer

The first step is heating the adhesive between the housing and the display. Without this step you won’t be able to get into the device.

My recommendation:

Lowest airflow setting
Maximum heat
About 2 minutes warming the entire housing
One corner more intensively (that’s where you want to open it first)

Temperature check: If you can just barely touch the tablet without burning yourself, it’s perfect!

In the video you can see exactly how long I hold the hair dryer and how!

Step 2: Open the Housing with a Suction Cup

Now comes the exciting part. Using a suction cup or suction cup clamp you carefully pull the housing apart.

Two options:

Option A: Suction cup clamp (the one I use)

Place it on the warmed corner
Carefully tighten until a gap appears
No force – just warm it up again if needed!

Option B: Two simple suction cups

One on the front, one on the back
Carefully pull apart with your hands
Again: patience matters more than strength

You’ll see in the video: In my case the housing pops open after just a few turns!

Step 3: Fully Open the Housing

Once the first gap appears, grab a plastic spatula or an old credit card.

Important:

⚠️ Do NOT use metal tools!
✅ Plastic only – that way you won’t scratch anything
✅ Don’t go too deep into the device
✅ Work your way completely around the device

If it doesn’t slide smoothly somewhere? Just warm up that spot with the hair dryer again. In the video I show you the right technique!

Step 4: Watch Out for Cables!

On my Samsung tablet: The back panel has no cabling – just lift it off.

On other tablets: Carefully check whether ribbon cables connect the back panel to the circuit board! Otherwise you’ll tear something off when opening it.

Step 5: Remove the Battery

Now it gets technical – but don’t worry, it’s easier than it looks!

On my tablet:

Loosen a few screws securing the battery
Carefully disconnect the ribbon cable
Gently lift the contact clips with a small screwdriver
Pull out the cable

In the video you can see every single step in close-up – I show you exactly where each cable sits!

Step 6: Remove the Old Battery

The battery is usually still secured with some adhesive tape. Carefully lift it and remove it from the housing.

Note: Don’t just throw the old battery in the trash! Batteries belong at the recycling center or at the collection point in an electronics store.

Step 7: Install the New Battery

The new battery goes in exactly the same spot.

Connection order:

Place the battery in the housing
Reconnect the ribbon cable
Press the contacts firmly
Screw the screws back in

In the video I show you what to pay attention to when connecting the cables!

Step 8: Function Test BEFORE Closing!

Important: Test that everything works BEFORE you close the housing!

What I test:

✅ Tablet can be switched on
✅ Display works
✅ Buttons respond
✅ Speakers work
✅ Battery charges (plug in the charging cable!)

In the video you’ll see the exciting moment: Does it turn on? 😊

Step 9: Calibrate the Battery

Before closing the housing, it’s a good idea to:

Charge the battery fully (100%)
Let the tablet drain completely without charging in between

Why? This way the operating system learns the actual capacity and can display accurate remaining runtime again.

Step 10: Close the Housing

Now comes the final step!

Option A: Use the remaining adhesion (what I do)

The old adhesive often still holds well enough
Simply press the back panel on and you’re done
⚠️ The device is then no longer waterproof

Option B: New adhesive strip

Remove the old adhesive
Apply a new adhesive strip (order it together with the battery!)
Good sealing again

For my Smart Home Dashboard, Option A is perfectly sufficient!

The Result: Mission Accomplished! 🎉

In just 20 minutes: My Samsung Tab runs for a whole week again, just from a new battery!

The tablet is back to being:

✅ Usable permanently as a dashboard
✅ Usable without constant recharging
✅ Ready for years more of service

Common Problems and Solutions

“The housing won’t open”

Solution: Heat it up again! Better to use the hair dryer for 30 seconds longer than to use force.

“I’m afraid of breaking something”

Solution: In the video you can see every move. Take your time and work calmly. Most damage happens from rushing!

“Which battery is the right one?”

Solution:

The exact model number is printed on the old battery
Search for that number at reputable shops
Read the reviews!

“The cable won’t connect”

Solution: Some connectors are a bit fiddly. In the video I show you how I handled the tricky connector on mine – it took me a while too!

Safety Notes

During the Repair

⚠️ Never work while connected to power!
⚠️ Do not damage the battery (risk of short circuit/fire!)
⚠️ Choose a well-ventilated room
⚠️ Keep children and pets away

After the Repair

✅ Supervise the first charging cycle
✅ The tablet getting warm is normal
✅ If you see smoke, disconnect from power immediately!

Why This Fits Perfectly with “Using Tech Smartly”

This channel is called “Smart Home? But Secure!” for a reason – and smart means:

Conserving resources instead of throwing things away
Taking action yourself instead of buying everything new
Understanding and mastering technology

A repaired tablet for a Smart Home Dashboard is the perfect example: Old meets Smart!

Your Repair Project?

Write to me in the comments:

Have you ever replaced a tablet or smartphone battery yourself?
What was your experience?
Do you also use your tablet for Smart Home?
Which device are you considering repairing?

Make sure to watch the video – there you can see every step live and get all the important tips!

More Repair Guides

Repair BROKEN Shellys – the 30 CENT repair that actually works! – Repair Smart Home hardware instead of throwing it away: save a Shelly 2.5 with a new capacitor
Repair Sonoff S20 Smart Plug – the 26 Cent Repair – Permanently fix the unstable WiFi connection on the Sonoff S20 with a capacitor replacement

Make Blinds Smart with Shelly: Local, No Cloud

Sun, 09 Nov 2025 00:00:00 +0000

The Problem: Electric Roller Shutters, But Not Smart

You have electric roller shutters or blinds, but still have to operate them directly at the wall switch? That’s a real shame, because an electric motor is already halfway there to a smart blind!

With a Shelly module, you can make your existing roller shutters smart and integrate them into your smart home – completely local, without any cloud dependency and surprisingly affordable.

In the new video I show you the complete implementation!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Why Shelly for Blinds?

✅ Completely Local

No cloud connection required
Works even during internet outages
Your data stays with you

✅ Affordable and Flexible

Shelly Plus 2PM: ~€20–25
Older Shelly 2.5: Even cheaper
Fits in any in-wall junction box

✅ Safe Installation

Built-in safety functions
Prevents simultaneous activation of both directions
Calibration for precise positioning

Choosing the Right Hardware

In the video I show various Shelly models:

Recommendation: Shelly Plus 2PM

Current successor model
Lowest price on the market
Perfect for blinds and roller shutters
Shelly Plus 2PM on Amazon (paid link) ← most affordable option Or directly at Shelly: Shelly (paid link, code SMARTHOMEABERSICHER-10OFF for 10% off)

Alternative: Shelly 2 Gen3

New generation with more features
Shelly 2 Gen3 on Amazon (paid link) Or at OBI: Shelly 2 Gen3 (paid link) Or directly at Shelly: Shelly (paid link, code SMARTHOMEABERSICHER-10OFF for 10% off)

Latest Generation: Shelly 2 Gen4

Newest version available
Shelly 2 Gen4 on Amazon (paid link) Or at OBI: Shelly 2 Gen4 (paid link) Or directly at Shelly: Shelly (paid link, code SMARTHOMEABERSICHER-10OFF for 10% off)

You can safely save money and stick with the Plus devices!

Wiring: What You Need to Watch Out For

Correct wiring is crucial! In the video I explain step by step:

Power Supply:

Neutral wire (N) and live wire (L) from the in-wall junction box
Connected to the corresponding terminals of the Shelly

Switch Connection:

Route the live wire through to the wall switch
“Up” switch and “Down” switch to S1 and S2
Order doesn’t matter – can be changed in software later

Motor Connection:

Outputs O1 and O2 to the roller shutter motor
O1: Move up
O2: Move down
Again: order can be changed later in software

⚠️ Important: Always follow the 230V electrical safety rules!

Software Setup: Safety First

1. Secure Initial Setup

In the video I show two approaches:

Recommended: Shelly App

✅ Uses Bluetooth (encrypted)
✅ More secure than hotspot
✅ Easy to use

Alternative: Hotspot

⚠️ Unencrypted
⚠️ Wi-Fi password can be intercepted
✅ Works without the app

2. Disable the Cloud

Important for local use:

Set Cloud Settings to “Disabled”
Set Server to “Disconnected”
Why? Complete local control

3. Device Profile: The Critical Setting

You absolutely must configure this:

Settings → Device Profile → “Cover”

Why is this so important?

Prevents simultaneous activation of both outputs
Without this setting: Motor damage is possible!
Shelly then “knows” it’s controlling a roller shutter

Calibration and Fine-Tuning

Check Directions

After the initial setup:

Test the buttons on the web interface
Wrong direction? → Enable Reverse Directions
Check wall switch → Enable Swap Inputs if needed

Calibration Run

Enables precise positioning:

What happens:

Roller shutter moves completely down
Then completely up
Stops at various intermediate positions
Result: Any position can be precisely controlled

In the video you can see the entire process live!

Home Assistant Integration

Automatic Discovery

It’s this easy:

Install the Shelly Integration in Home Assistant
New devices are discovered automatically
One click → Integration complete

Dashboard and Automations

After integration:

✅ Display roller shutters on the dashboard
✅ Create automations:
- Automatic opening/closing
- Sun protection during intense sunlight
- Time-based schedules

Tip: I’ll show more blind automations in Home Assistant in an upcoming video!

Practical Benefits in Daily Life

Convenience

App control from anywhere in the home
Automation based on time of day
Scenes for different situations

Security

Presence simulation while on vacation
Automatic closing during storms
Integration into a security system

Energy Efficiency

Intelligent sun protection reduces cooling costs
Heat retention in winter by closing at the right time
Light optimization through precise positioning

Cost-Benefit Analysis

Investment:

Shelly Plus 2PM: ~€20–25
Installation: DIY-friendly with basic knowledge
Ongoing costs: None (local solution)

Alternative: Ready-Made Smart Blinds

Cost: €200–500+ per roller shutter
Cloud dependency: Usually required
Flexibility: Tied to the manufacturer

Conclusion: The Shelly solution is significantly cheaper and more flexible!

Avoiding Common Mistakes

❌ Forgetting the Device Profile

Problem: Motor can be damaged Solution: Always set it to “Cover”

❌ Wrong Wiring

Problem: Roller shutters move in the wrong direction Solution: Correction possible in software

❌ Leaving the Cloud Enabled

Problem: Dependency on manufacturer servers Solution: Deliberately disable the cloud

❌ Skipping Calibration

Problem: No precise positioning Solution: Run the calibration sequence

The Video Shows Everything Live

In the video you’ll see:

✅ Hardware comparison of various Shelly models
✅ Wiring diagram explained in detail
✅ Software setup step by step
✅ Home Assistant integration live
✅ Calibration in action
✅ Practical tips from my own installation

What’s Next: Even More Smart Home

More Shelly Use Cases:

Heating control (dedicated video available)
Light control with dimming
Garage door automation

Complex automations (upcoming video)
Time-based schedules
Weather-dependent control

Let me know in the comments:

How do you currently control your roller shutters?
Do you already have experience with Shelly?
What automation ideas do you have?

Make sure to watch the video – it shows every step live and gives you all the important details for a safe installation!

When Your Smart Home Suddenly Goes Dumb – What to Do

Sun, 02 Nov 2025 00:00:00 +0000

Every Smart Home Owner’s Nightmare

Imagine coming home, opening your smart home app – and suddenly it shows “No Connection.” Not because of an internet outage or a technical glitch, but because the manufacturer simply pulled the plug.

This is happening on a massive scale right now: Bose is shutting down the cloud for SoundTouch, Vorwerk is killing off Neato robot vacuums, and the list grows longer every day. Devices that cost over €1,000 are being turned into expensive paperweights overnight.

But it doesn’t have to be this way! In this video I explain why this happens and how you can protect yourself.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Recent Cases: When Smart Homes Go Dumb

Bose SoundTouch: The €1,000 Paperweight

As of February 18, 2026, Bose is discontinuing cloud support for the entire SoundTouch product family. That means:

❌ Spotify integration is gone
❌ TuneIn radio no longer works
❌ Multiroom features are history
❌ App control is heavily restricted

Bose’s explanation: The technology has been “extensively further developed” and the company is “no longer able to maintain the cloud infrastructure.”

Translation: Running the cloud costs too much money.

Vorwerk/Neato: A Broken Promise

Even more egregious is the Vorwerk case: the company had promised five years of cloud operation for Neato robots. Did they keep that promise? Apparently not.

In 2023, Neato Robotics was shut down, and now all cloud services are being terminated. Even robots that were still sold regularly in 2023 are losing their functionality.

Vorwerk’s excuse: “Cybersecurity standards have evolved.”

The truth: They failed to invest in time – or simply didn’t want to.

The Mechanics of the Cloud Disaster

Why does this keep happening? The video explains the vicious cycle:

Phase 1: The Launch

Manufacturer develops a new product
Cloud enables modern features (remote access, updates, etc.)
Sales revenue funds cloud operation

Phase 2: Technical Progress

New device generation requires new cloud architecture
Manufacturer operates two cloud systems in parallel
Double the costs, half the benefit

Phase 3: The End

Old devices no longer sell
Cloud operation becomes a pure cost factor
Pulling the plug is the “economical” solution

Your Checklist: How to Protect Yourself

1. Check Manufacturer Reputation

Before you buy: How has the company behaved in the past?

Are there already reports of discontinued products?
How transparently does the company communicate?
Google search: “[Manufacturer] + cloud shut down”

2. Test Local Features

The most important question: Does the device work without internet?

Can you switch lights on/off during a Wi-Fi outage?
Does the robot vacuum start offline?
Does the heating control run independently?

Rule of thumb: The more features available locally, the safer you are.

3. Question Update Promises

Does the manufacturer specify support periods?

How long will updates be provided?
Are there written guarantees?
Silence is often not a good sign!

4. The Free Cloud Paradox

Warning: Free cloud services are often a red flag!

If a manufacturer only makes money from hardware sales but provides cloud services for free, that model won’t be sustainable long-term.

Better: Transparent subscription models create sustainable value for both sides.

Positive Examples: How It Should Be Done

Philips Hue: Local Foundation + Premium Cloud

Core functions: Fully local via the Bridge
Premium features: Optional via Bridge Pro (one-time purchase)
Transparency: Clear separation between free and paid

Link: Philips Hue Bridge Pro

Aqara: Hub-Based Architecture

Local control: All basic functions without cloud
Cloud access: Optional for remote access and extended features
Fair pricing: Transparent cost structure

Link: Aqara Smart Hubs

What You Can Do Right Now

Immediate Actions:

Inventory: Which of your devices depend on the cloud?
Test: Do they work offline?
Research: What is the manufacturer’s track record?

Before Your Next Purchase:

Prioritize local features
Prefer open standards (Zigbee, Z-Wave, Matter)
Support transparent business models

Long-Term:

Set up Home Assistant or a similar local system
Buy fewer cloud-dependent devices
Factor in community support when making purchasing decisions

The Bottom Line: Your Smart Home Belongs to YOU

As the Süddeutsche Zeitung aptly put it: “Anyone buying technology today is handing themselves over to the manufacturer.”

But it doesn’t have to be this way! With the right preparation and conscious purchasing decisions, you can build a smart home that belongs to you – not to the manufacturer’s cloud.

The full video walks you through everything step by step – from concrete checklists to positive examples to action recommendations for your existing setup.

What do you look for when buying smart home products with cloud features? Have you ever had a manufacturer pull the plug on functionality you relied on?

Write it in the comments – your experience helps others make better purchasing decisions!

Home Assistant A-Z: G is for Devices – All United

Tue, 28 Oct 2025 00:00:00 +0200

You have Philips Hue bulbs, a Shelly relay, an Aqara sensor, and a Fritz!Box – and you want them all to “talk” to each other? With conventional smart home hubs, that’s a nightmare of different apps and incompatible systems. With Home Assistant? A walk in the park.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What Are Devices in Home Assistant?

Devices are all the physical and virtual components that Home Assistant can recognize and control. These can be lights, switches, sensors, cameras – or even software services like weather information.

The key difference from other smart home systems: Home Assistant is manufacturer-independent. While Amazon Alexa, Apple HomeKit, or Samsung SmartThings often only support devices from specific brands or with special certifications, Home Assistant brings all your devices under one roof – regardless of manufacturer.

The Secret: Integrations

This works through so-called integrations. For almost every manufacturer there is an integration that handles the “translation” between the device and Home Assistant. Over 1,000 different integrations are available – from major brands to niche products.

Why Does This Matter for Your Smart Home?

The End of App Chaos

Imagine this: you already have Philips Hue bulbs, but then you buy some cheaper IKEA Tradfri bulbs as well. With most commercial hubs, you now have to use two separate apps and can’t control the lights together.

Home Assistant solves this elegantly: Both lighting systems simply appear as “lights” in the same interface. You can use them together in automations, switch them in the same scene, or display them on the same dashboard.

Save Money Through Manufacturer Diversity

This saves not just frustration, but also money. You can pick the best value from different manufacturers:

Affordable Xiaomi sensors for basic coverage
High-quality Philips Hue bulbs for key areas
Robust Shelly relays for electrical installations
Budget-friendly IKEA buttons for control

Future-Proofing

If a manufacturer shuts down or changes its policy? No problem – you simply swap out individual devices without having to rebuild your entire system. Your automations and configurations remain intact.

How Does It Work in Practice?

Adding Devices

The video shows the practical workflow: you add devices via integrations. The path is Settings → Devices & Services.

Here you can see all your already-configured integrations and add new ones. Home Assistant even auto-discovers many devices on your network – these appear under “Discovered”.

Practical Example: Shelly Integration

The video demonstrates integrating a Shelly 1PM switch:

Click “Add Integration”
Search for “Shelly”
Select the official Shelly integration
Enter the device’s IP address
Done!

The Shelly appears as a device with several entities: the switch itself, a power meter, and an energy counter. Each entity can be used in automations, dashboards, or scenes.

Different Connection Types

Wi-Fi devices: Directly over the network
Zigbee/Z-Wave: Via the respective coordinators
Cloud services: Weather data, energy providers, etc.
Local APIs: Direct device communication

Avoiding Common Pitfalls

Overwhelmed by Choice

Problem: Over 1,000 available integrations can feel overwhelming.

Solution: Start small! Begin with the devices you already own and expand gradually. Not everything has to be perfect from day one.

Outdated Integrations

Problem: Not all integrations are maintained equally well.

Solution: Before installing, check the documentation and whether the integration is still actively developed. Official manufacturer integrations are usually your best bet.

Missing Documentation

Problem: With many different devices it’s easy to lose track.

Solution: Document your setup! Write down which devices you configured and how – this saves a lot of time when troubleshooting later.

Creative Device Combinations

The beauty of manufacturer independence shines especially in cross-vendor automations:

Practical Examples

Affordable Xiaomi motion sensor controls premium Philips Hue bulbs
IKEA button connected to Sonos speakers
Fritz!Box call notifications mute Samsung TVs
Shelly energy readings combined with Tibber electricity prices

The Best of All Worlds

Every manufacturer has its strengths:

Philips: The best lighting and most refined features
Shelly: Robust and versatile relays for electrical work
Aqara: Affordable and reliable sensors
IKEA: Budget-friendly buttons and starter hardware

With Home Assistant you combine these strengths without having to compromise.

Why Home Assistant Beats Other Hubs

Local Processing

While commercial hubs often depend on cloud connections, Home Assistant runs entirely locally. That means:

Faster response times
Greater reliability
Better privacy
No dependency on manufacturers

Open Standards

Home Assistant relies on open protocols and standards rather than proprietary solutions. This makes the system future-proof and manufacturer-independent.

Community Development

With an active community of developers, new integrations are constantly being created. Even niche manufacturers are often supported shortly after their products launch.

What You’ll Learn in the Video

The video shows you the practical aspects that are hard to convey in writing:

Live integration of various devices
Navigation through the device interface
Entity management in practice
Troubleshooting tips for common problems
Dashboard integration of newly added devices

The visual demonstration is especially helpful for understanding the difference between devices and entities – a concept that confuses many beginners.

Conclusion: One Hub, All Devices

Home Assistant finally delivers on the smart home promise: one system that truly unites all your devices. Whether cheap or expensive, old or new, well-known or exotic – Home Assistant brings them together.

The video demonstrates this strength impressively and shows why Home Assistant is the better alternative to commercial hubs for many people. From the first integration to complex automations – you see everything step by step.

Home Assistant A-Z: I is for Integrations

Sun, 26 Oct 2025 00:00:00 +0000

Welcome to the A-Z Series: I is for Integrations

In today’s episode of our Home Assistant A-Z Series we dive into one of the most powerful concepts in the smart home universe: integrations. These small software building blocks are what transform Home Assistant from a mere collection of devices into a genuinely intelligent, interconnected system.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What Are Integrations?

Integrations are the bridges between different systems and services. They allow Home Assistant to communicate with a wide variety of devices, services, and APIs. Without integrations, your smart home would be nothing more than a collection of isolated islands.

The Power of Connection

Integrations solve three fundamental problems:

Compatibility: They translate between different protocols
Functionality: They extend Home Assistant with new capabilities
Automation: They provide the foundation for intelligent rules

Three Practical Integrations in Detail

1. Workday Binary Sensor - Intelligently Detecting Working Days

The Workday Binary Sensor is a perfect example of a simple yet powerful integration. It automatically detects whether today is a working day, taking into account:

Weekends
Public holidays
Vacation days
Different countries and regions

Example configuration:

1
2
3
4
5
6


# Example configuration
binary_sensor:
 - platform: workday
 country: DE
 workdays: [mon, tue, wed, thu, fri]
 excludes: [sat, sun, holiday]

Automation examples:

Turn up the heating early only on working days
Activate the alarm clock only on weekdays
Increase garden irrigation on days off

2. Thermal Comfort - The Perceived Temperature

The Thermal Comfort integration calculates how temperature actually feels. It takes into account:

Air temperature
Humidity
Additional environmental factors

Why this matters: 20°C at 30% humidity feels completely different from 20°C at 70% humidity. This integration helps you understand and automate the actual comfort climate in your home.

Automation potential:

Control heating based on perceived temperature
Intelligently regulate a humidifier
Optimize comfort levels in different rooms

3. Waste Collection Schedule - Never Miss Trash Day Again

The Waste Collection Schedule integration connects to local waste collection calendars and automatically informs you about:

Upcoming collection dates
Different waste types (general waste, recyclables, paper, organic)
Rescheduling due to public holidays

Smart home magic:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# Example: trash reminder
automation:
 - alias: "Put out trash reminder"
 trigger:
 - platform: time
 at: "20:00:00"
 condition:
 - condition: template
 value_template: "{{ state_attr('sensor.waste_collection_bio', 'days') == 0 }}"
 action:
 - service: notify.mobile_app
 data:
 message: "Organic waste will be collected tomorrow!"

Integration vs. Add-on - What’s the Difference?

A common source of confusion: What is the difference between integrations and add-ons?

Integrations:

Extend Home Assistant with new sensors and services
Run within the Home Assistant Core
Primarily used for external services and APIs

Add-ons:

Standalone applications
Run in separate containers
Examples: Node-RED, ESPHome, Mosquitto

Exploring the Integration Library

Home Assistant offers over 3,000 official integrations. The main categories:

Hardware Integrations

Philips Hue
IKEA TRÅDFRI
Shelly
Sonos

Service Integrations

Weather APIs
Calendar services
Streaming platforms
Smart meters

Utility Integrations

Template sensors
Input helpers
Scene controllers

Best Practices for Integrations

1. Less is more

Only install integrations you actually need. Every integration consumes resources.

2. Read the documentation

Each integration has specific configuration options. The official documentation is your friend.

3. Use a test environment

Test new integrations in a copy of your configuration first.

Troubleshooting Common Issues

Integration won’t load

Check dependencies: Are all required Python packages installed?
Validate configuration: Any syntax errors in your YAML?
Check the logs: What do the Home Assistant logs say?

Performance issues

Adjust polling intervals: Not every sensor needs to be queried every second
Disable unnecessary attributes: Reduce the amount of data
Optimize entity names: Use descriptive names

Developing Your Own Integrations

For advanced users: Home Assistant is open source! You can:

Customize existing integrations
Develop new integrations
Contribute to the community

Get started with the Developer Documentation.

Integration Recommendations for Beginners

Must-have integrations:

Weather - Weather data for automations
Sun - Sunrise/sunset for lighting
Mobile App - Notifications and location
Time & Date - Time-based automations

Advanced integrations:

Node-RED - Visual automation editor
InfluxDB - Long-term data history
Grafana - Advanced dashboards
AppDaemon - Python-based automations

The Future of Integrations

Home Assistant is constantly evolving. Emerging trends:

Matter/Thread support - The new smart home standard
Cloud-native integrations - Better performance
AI/ML integration - Artificial intelligence in the smart home
Voice assistants - Even more natural interaction

Managing Your Integrations

Via the UI

Since Home Assistant 2021.3, most integrations can be managed through Settings > Devices & Services.

YAML configuration

Some integrations still require manual YAML configuration in configuration.yaml.

Custom integrations

Through HACS (Home Assistant Community Store) you can also install community integrations.

Summary

Integrations are the heart of every successful smart home. They:

Connect different systems
Extend functionality without new hardware
Enable intelligent automations
Solve specific everyday problems

The three integrations covered here - Workday Binary Sensor, Thermal Comfort, and Waste Collection Schedule - show just how versatile and practical these small helpers can be.

Next Steps

Explore the integration library in your Home Assistant installation
Experiment with the three integrations presented here
Stay tuned for the next part of our A-Z Series

Shelly Makes Your Heating Smart – No More Thermostats

Sun, 19 Oct 2025 00:00:00 +0200

Ever dealt with thermostats like these? Whether it’s an analog dial with numbers 1–6 or a digital thermostat with tiny buttons — they drove me crazy. That’s why, three years ago, I replaced almost all my room thermostats with Shelly relays paired with temperature sensors.

The result after three years: It was the best Smart Home decision I ever made. See for yourself in the video.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Why Classic Thermostats Are Frustrating

The Problem with Analog Thermostats

Analog rotary thermostats with a scale from 1 to 5 are completely abstract and disconnected from reality. What does level 3 actually mean? What temperature does that correspond to? Nobody really knows.

The worst part: you always have to adjust them manually:

Turn the heating down in the evening
Turn it back up in the morning
Lower it before going on holiday
Come home from holiday to a cold flat

Digital Thermostats: Not Much Better

Digital thermostats can display temperatures and often include scheduling features, but using them is frustrating:

Tiny buttons that require a firm press
Complicated menus that are barely understandable without the manual
Holiday mode that works in only 50% of cases
Expensive — often over €100 per device

In the video I demonstrate these problems live — you’ll definitely recognise the situation!

The Shelly Solution: Smart, Affordable, Reliable

Why Shelly Instead of Expensive Smart Thermostats?

While branded smart thermostats often cost over €150, Shelly gives you a fully capable solution for under €50:

Shelly 1 Gen4 (or the Plus series): The core component (approx. €15–20)* – also at OBI* or directly at Shelly* (code SMARTHOMEABERSICHER-10OFF for 10% off)
Shelly Plus Add-on: For the temperature sensor (approx. €15)* – also at OBI* or directly at Shelly* (code SMARTHOMEABERSICHER-10OFF for 10% off)
DHT22 temperature sensor: For measurement (approx. €5)*

The brilliant part: The system runs completely standalone. Even if your Wi-Fi goes down or your Smart Home system has issues, the Shelly continues to regulate your heating!

Hardware Overview from the Video

In the video I walk through all the components in detail:

Shelly first vs. new generation — differences and pros/cons
Shelly Plus Add-on — why external sensors beat centralised solutions
DHT22/AM2302 temperature sensor — affordable, reliable, and widely available
Wiring and pin assignments — shown step by step

The Wiring Secret

An important point from the video: The Shelly generates heat inside the in-wall box, which affects the temperature reading.

My solution: Foam padding between the Shelly and the sensor, plus correct calibration using the temperature offset setting. The video shows exactly how this works.

Temperature Calibration: The Key to Success

Why Calibration Matters

Even with foam insulation, there remains a temperature difference between the in-wall box and the actual room temperature. The solution: Temperature offset in the Shelly settings.

I demonstrate live in the video:

Comparing Shelly readings against a room thermometer
Setting the offset on older Shellys (External Sensors)
Setting the offset on newer Shellys (Temperature Offset)
Differences of 0.6 to 4 degrees depending on the installation

Setting Up Standalone Heating Control

This is the core of the solution: The Shelly controls the heating completely independently, without relying on your Smart Home system.

For Shelly 1 (first generation):

Enable Temperature Automation
Relay Off temperature: e.g. 21°C
Relay On temperature: e.g. 21.5°C
Done!

For Shelly Plus (new generation):

Create two actions: “Heating on” and “Heating off”
Trigger: temperature change
Conditions: above/below target temperature
Action: output on/off

The video shows both variants step by step!

Home Assistant Integration for Power Users

A Dashboard for All Radiators

Why the video is especially valuable: I show you my complete heating dashboard after three years of real-world use:

Overview of all rooms with current temperature
Individual setpoints for day and night
Schedules for automatic setback
Status display showing when each radiator was active

REST API Integration: The Pro Trick

Here’s where it gets technical: The standard Shelly integration in Home Assistant cannot set temperature values.

The solution: Call the REST API directly:

REST sensors to read current settings
REST commands to set new target temperatures
Different endpoints for old vs. new Shellys

The video shows the complete code and how to add it to your configuration.yaml.

Reading Temperature: REST Sensors

For Shelly 1 (first generation):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


rest:
 - resource: 'http://shelly1-hostname/settings/ext_temperature/0'
 sensor:
 - name: "Heating Target Temperature"
 value_template: >
 {{ value_json.overtemp_threshold_tC }}
 unit_of_measurement: "°C"
 json_attributes_path: "$"
 json_attributes:
 - "overtemp_threshold_tC"
 - "undertemp_threshold_tC"
 - "overtemp_act"
 - "undertemp_act"
 - "offset_tC"

For Shelly Plus (new generation):

1
2
3
4
5
6
7


rest:
 - resource: 'http://shellyplus-hostname/rpc/Webhook.List?id=1'
 sensor:
 - name: "Heating Target Temperature"
 value_template: >
 {{ value_json.hooks[1].condition[7:] }}
 unit_of_measurement: "°C"

What’s happening here?

resource: The URL of your Shelly device from which the data is fetched
sensor: Defines a new sensor in Home Assistant
name: The name under which the sensor will be displayed
value_template: Extracts the temperature value from the JSON response
json_attributes: Stores additional values as sensor attributes

Advantage: You get not just the current setpoint, but also other useful information displayed directly in Home Assistant!

Setting Temperature: REST Commands

1
2
3
4
5
6
7


rest_command:
 set_shelly1_heating:
 url: 'http://{{host}}/settings/ext_temperature/0?overtemp_threshold_tC={{((temp|float)|string)}}&undertemp_threshold_tC={{((temp|float - 0.5)|string)}}'
 set_shelly1plus_heating_high:
 url: 'http://{{host}}/rpc/Webhook.Update?id=2&condition="ev.tC%20>%20{{((temp|float)|string)}}"'
 set_shelly1plus_heating_low:
 url: 'http://{{host}}/rpc/Webhook.Update?id=1&condition="ev.tC%20<%20{{((temp|float - 0.5)|string)}}"'

What’s happening here?

For Shelly 1: A single HTTP GET sets both temperature values at once:

overtemp_threshold_tC: The upper temperature (heating off)
undertemp_threshold_tC: The lower temperature (heating on, 0.5°C lower)

For Shelly Plus: Two separate calls are required:

set_shelly1plus_heating_high: Sets the upper temperature threshold
set_shelly1plus_heating_low: Sets the lower temperature threshold

Parameter explanation:

{{host}}: Variable for the Shelly IP address
{{temp}}: Variable for the desired target temperature
temp|float - 0.5: Automatically calculates the hysteresis (0.5°C difference)

Using REST Commands in Automations

How to use the REST commands in Home Assistant:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


automation:
 - alias: "Set Heating Temperature"
 trigger:
 - platform: state
 entity_id: input_number.heizung_soll_temperatur
 action:
 - service: rest_command.set_shelly1_heating
 data:
 host: "192.168.1.100"
 temp: "{{ states('input_number.heizung_soll_temperatur') }}"

Advanced Automations Are Possible

The system can be extended with:

Window sensors: Turn off heating when a window is open
Presence detection: Setback when nobody’s home
Weather forecast: Predictive control

Why I skip these: With underfloor heating the system is too sluggish for short-term adjustments.

Three Years in Practice: My Honest Verdict

What Works Perfectly

After three years I can say: The system runs absolutely reliably:

Not a single notable failure
No Wi-Fi issues like those seen with other Smart Home devices
Precise temperature control after calibration
Maintenance-free — set it once and forget it

Cost Comparison with the Alternative

My old Jung thermostats cost over €100 per unit and offered fewer features. The Shelly solution:

Cheaper to buy
More flexible to program
More future-proof thanks to open standards
Easier to repair if something breaks

Energy-Saving Experiment in Progress

I’m currently testing: Does nighttime setback actually save energy with underfloor heating? To find out, I’ve set identical day and night temperatures in my dashboard and am comparing energy consumption.

The video also shows these details from my day-to-day use.

What You’ll Learn in the Video

This video is especially valuable because you’ll see:

Live demonstration of all hardware components
Practical wiring inside a real in-wall box
Calibration process with actual values
Dashboard configuration from three years of experience
Code examples for Home Assistant integration
Honest assessment after long-term use

Suitable for All Experience Levels

Whether you’re a beginner or a pro:

Hardware basics explained clearly
Step-by-step instructions you can follow along
Advanced integration for Home Assistant users
Extension ideas for your own projects

Making Garage Doors Smart with Shellys — The Shelly principle applied to garage doors
Smart Blinds with Shelly — Done Safely — Local roller shutter control with Shelly Plus 2PM
Repairing BROKEN Shellys — The 30-Cent Fix That Actually Works! — When older Shelly devices start causing problems after a few years

Home Assistant A-Z: H is for Helpers – Secret Heroes

Sun, 12 Oct 2025 00:00:00 +0200

Do you ever forget to take out the trash? Or have your automations grown so complex that even you can no longer keep track? Home Assistant helpers are the solution! These unassuming features can revolutionize your smart home life.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What exactly are helpers?

Helpers are virtual entities in Home Assistant that act as “memory” or temporary storage for your automations. They can store states, perform calculations, or simply serve as digital sticky notes.

The brilliant part: Helpers exist only inside Home Assistant — they are not physical devices. Yet they behave just like real entities and can be used in all automations, dashboards, and scenes.

The most important helper types:

Toggle (Input Boolean): On/Off states
Number (Input Number): Values between a minimum and maximum
Text (Input Text): Store arbitrary text
Select (Input Select): Predefined options
Date/Time (Input Datetime): Remember specific points in time

Why helpers improve your smart home

Problem 1: Forgotten tasks

Sound familiar? Push notifications are swiped away in a second — and then forgotten. The video shows a clever solution: An automation reminds you the evening before to put out the trash bin. But instead of just sending a push notification, it also turns on a helper.

The helper appears as a tile on the dashboard — and stays there until you’ve completed the task and turn it off again. No more forgetting!

Problem 2: Complex automations

The more complex your automations become, the harder troubleshooting gets. The video shows a real-world example: A shading automation split into two parts:

One automation calculates whether the sun is shining on a particular side of the house
A second automation uses that result to control the blinds

The advantage: When something goes wrong, you can immediately see in the helper whether the sun calculation is working correctly. Complex logic is broken down into digestible pieces.

Problem 3: State management

The most powerful example in the video: A helper that manages the entire home status. With just four states (Home, Away, Vacation, Night), dozens of automations are controlled:

Light automations distinguish between day and night
Security features activate when nobody is home
Energy-saving functions kick in during vacation mode
Warnings trigger for open windows when leaving the house

One central helper replaces complex conditions in every single automation.

Practical helper ideas for your smart home

Digital reminders

Watering plants: Weekly reminder with dashboard display
Maintenance tasks: Filter changes, battery checks, etc.
Appointments: Trash collection, cleaning service, tradespeople

Storing intermediate values

Average temperatures: Combine multiple sensors into one value
Energy calculations: Break complex formulas into steps
Presence detection: Combine various sensors into one result

Complex states

Weather modes: Sunny, rainy, windy — for different automations
Activity modes: Working, relaxing, sleeping, party
Security levels: Normal, heightened, vacation, maintenance

Using helpers correctly — what the video shows

The video walks you through step by step:

Where to find helpers — Navigating to the settings
How to configure helpers — Practical examples
Integration into automations — Concrete usage
Dashboard display — User-friendly presentation
Troubleshooting — How to spot problems

Especially valuable: the live demonstration

Explaining helpers in writing is one thing — seeing them in action is another. The video impressively demonstrates:

How the dashboard changes when a helper is activated
The connection between automations and helpers
Practical clicks through the user interface
Real use cases from a working smart home

Avoiding common beginner mistakes

Too many helpers at once

Mistake: Creating dozens of helpers for every possible scenario right away. Better: Start with one or two simple helpers and build experience from there.

Confusing names

Mistake: Naming helpers something like “Boolean1” or “Input_xyz”. Better: Use descriptive names like “Trash_Yellow” or “House_Status”.

No documentation

Mistake: Coming back months later with no idea what a helper was for. Better: Write descriptions into the helper configuration.

Why you should definitely watch the video

Helpers are a game changer for Home Assistant — but their full potential only reveals itself once you understand and use them correctly. The video shows three completely different use cases that illustrate just how versatile these seemingly simple tools are.

You’ll learn concretely:

How to work with the helpers interface in practice
How helpers can improve your existing automations
Pro tips for complex state management
Why one well-designed helper can replace dozens of complicated conditions

Three complexity levels in the video

Beginners: The trash reminder is a perfect entry point
Intermediate: The shading logic shows helpers as automation building blocks
Advanced: The home status management demonstrates enterprise-level smart home architecture

No matter what level you’re at — you’re guaranteed to find new ideas for your smart home!

The difference from other smart home systems

While commercial smart home hubs often impose rigid structures, Home Assistant helpers give you the freedom to design your system around your own needs.

The video shows this impressively: With just a few clicks you can create tailor-made solutions that simply wouldn’t be possible in other systems. This flexibility is what makes Home Assistant so powerful — and helpers are a big part of that.

Conclusion: Small helpers, big impact

Helpers are the secret heroes of your smart home installation. They work invisibly in the background, simplify complex automations, and make your system more maintainable and understandable.

The video perfectly demonstrates their versatility — from simple reminders to complex state management. After watching, you’ll see your smart home with fresh eyes and will surely discover your own use cases for helpers.

What’s your favorite helper? Write it in the comments! And if you’re enjoying this A-Z series, check out the other episodes — each one brings you one step closer to becoming a smart home pro.

ESPHome After the Security Flaw: Still Acceptable?

Sun, 05 Oct 2025 00:00:00 +0200

“Is it irresponsible to use ESPHome?” That was the question I posed after my last video about the critical ESPHome security vulnerability. The reactions were fascinating — and often sharply divided.

Comments ranged from harshly critical to completely relaxed: from “There’s a lot more going wrong here — ESPHome developers have apparently never heard of HTTPS or password hashing” to “And what would be the reward for this extraordinary hacking effort? Turning on the light in my garage? 🤣”

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Who’s right? A balanced look at the community discussion and practical recommendations for ESPHome users.

The Criticism of ESPHome: Justified or Overblown?

Structural Security Problems

Many comments highlighted fundamental security issues in ESPHome, and this criticism is hard to dismiss:

Multiple authentication bugs over the years — not exactly confidence-inspiring
Lack of HTTPS support and weak password hashing, both of which are long-established industry standards
Firmware upload via the web server — possible regardless of password protection

The frustration of many users is entirely understandable. HTTPS ensures that nobody on the local network can intercept HTTP traffic. Password hashing stores credentials not in plain text but as a cryptographic checksum. Both have been established security standards for years.

As I explain in the video, ESPHome shows clear weaknesses here.

Open Source: Curse or Blessing?

ESPHome illustrates a classic open-source dilemma: security is often not the top priority. Developers typically focus on features and functionality — security considerations come later, if at all.

At the same time, it’s a sign of a healthy, active community when vulnerabilities are found and reported. The sheer number of disclosed issues says little about a project’s actual security posture. Other projects may contain just as many vulnerabilities — they just haven’t been discovered or made public yet.

In the video I dig into this dilemma in detail and explain why the assessment isn’t straightforward.

The Web Server Problem

One pattern stands out with ESPHome: most vulnerabilities affect the built-in web server. This leads to a simple recommendation: only enable the web server if you actually need it.

Practical tip: If you’re using ESPHome nodes with Home Assistant, the web server is generally not necessary. Communication runs directly through the ESPHome API. And these devices should never be exposed to the internet anyway — so absolutely no port forwarding for ESPHome nodes!

“My Home Network Is Secure” — A False Sense of Safety

The LAN Illusion

A common argument goes: “The attacker would first have to get into my LAN — my local home network — so it’s fine.” Some people even dismiss the threat with quips like “Sure, someone might turn on my garage light.”

But that’s exactly where false security sets in. Modern attack vectors make it surprisingly easy for attackers to get into home networks:

Infected IoT devices as an entry point
XSS attacks in the browser enabling remote access
Insecure router configurations
Compromised smartphones or laptops

In the video I show concrete examples of how quickly this supposed safety net becomes a trap.

Cross-Site Scripting Explained

XSS, or Cross-Site Scripting, works like this: an attacker builds a manipulated web page that executes foreign code in your browser. You notice nothing, but in the background the attacker can steal data or execute commands — almost as if they were directly inside your home network.

Example: You click on what looks like a harmless link. In the background, a hidden JavaScript function sends requests to your ESPHome devices. Just like that — garage door open, heating off, lights on.

Network Architecture: Theory vs. Practice

The VLAN Discussion

One of the most interesting aspects of the community debate: network segmentation. The theory is clear: IoT devices belong in separate networks, ideally VLANs — virtual networks that isolate devices from one another.

This is definitely best practice. But many users point out: “In reality, hardly anyone does this in private networks because it’s too complicated.” On top of that, true VLAN separation is often impossible with standard consumer hardware.

That’s exactly the crux: theory versus practice. I explore this discussion from the comments thoroughly in the video.

Practical Alternatives

When full network segmentation is too complex, there are practical alternatives:

Guest Wi-Fi for IoT devices
Firewall rules for IoT traffic
Dedicated IoT routers as a separate network layer
Unifi, OPNsense, or pfSense for advanced network features

The effort should match the threat level — not everyone needs enterprise-level segmentation for their smart home.

An OTA Password Alone Is Not Enough

A False Sense of Security

A common misconception: “I’ve set an OTA password, so I’m safe.” OTA stands for “Over-the-Air” — firmware updates delivered over the network.

Unfortunately, no — for the critical ESPHome vulnerability, the OTA password provided no protection whatsoever. The flaw wasn’t in the OTA module but in the web server module, which also offered firmware upload functionality.

I explain in the video, with a practical demonstration, exactly why the OTA password was ineffective in this case.

The Swiss Cheese Model

In the end, the takeaway is this: apply updates promptly and combine multiple layers of protection.

The Swiss Cheese Model describes this principle well: each individual security layer has holes, but stacked together they form effective protection.

Example layers of protection:

Router firewall blocks external access
Network segmentation isolates IoT devices
Strong passwords defend against brute-force attacks
Timely updates close known vulnerabilities
Disabling the web server reduces the attack surface

Two Security Mindsets: Paranoia vs. Pragmatism

The Two Camps

The comments reveal two clearly defined camps:

Team Security: “You have to patch everything, segment everything, harden everything”
Team Pragmatism: “The risk is too small — I don’t want to live my life in paranoia”

Both perspectives are understandable, but in IT security, gut feeling is rarely a reliable guide. In the video I address both mindsets and explain why a fact-based assessment matters.

The Facts: CVSS 8.1

The ESPHome vulnerability was rated 8.1 under CVSS, classified as “High”. CVSS is the standard scoring system for security vulnerabilities, ranging from 0 to 10, and 8.1 is firmly in the critical range.

For reference:

0–3.9: Low (minor risk)
4.0–6.9: Medium (moderate risk)
7.0–8.9: High (high risk)
9.0–10.0: Critical (critical risk)

At 8.1, this is a vulnerability you definitely should not ignore.

A detailed breakdown of the CVSS score and what it means for ESPHome users is in the video.

Practical Recommendations for ESPHome Users

Immediate Actions

Update ESPHome to the latest version (>= 2024.6.2)
Enable the web server only when necessary — not needed for Home Assistant integration
Never expose ESPHome nodes to the internet — no port forwarding!
Use strong, unique passwords for OTA updates

Advanced Security Measures

Implement network segmentation wherever possible
Use a VPN for remote access instead of direct internet exposure
Keep all IoT devices updated regularly
Monitor network traffic for suspicious activity

Long-Term Considerations

Abandon ESPHome entirely? That seems excessive to me. The platform offers enormous value for DIY smart home projects. With the right precautions, the risk can be reduced to an acceptable level.

In the video I explain in detail why I still recommend ESPHome despite its security issues — but only under certain conditions.

Alternatives: Tasmota, the Arduino framework directly, or commercial IoT devices. But these all come with their own security problems — perfect security doesn’t exist anywhere.

Conclusion: Security Is Never Black and White

The community discussion makes one thing clear: security is never black and white. There are best practices, but in practice you have to decide how much effort to invest for how much risk reduction.

My personal take: If an update is available, why wouldn’t you apply it? It’s the easiest way to add one more security layer.

The golden rule: Stay informed, understand the threats, respond appropriately — but don’t tip into paranoia.

Using ESPHome after the security vulnerability is not irresponsible, as long as you take the right precautions. The project does have security issues, but with a mindful approach it remains a valuable option for DIY smart home enthusiasts.

The complete analysis of the community reactions and all practical tips for using ESPHome securely are in the video above.

→ The specific vulnerability this article refers to is covered in a separate video with a live demonstration: ESPHome Security Vulnerability: Critical CVE Affects All ESP32 Devices

Repairing Broken Shellys: the 30-Cent Fix That Works

Sun, 21 Sep 2025 00:00:00 +0200

Is your Shelly 2.5 humming? Making strange noises or constantly dropping the Wi-Fi connection? Then you are probably familiar with the frustrating problem that many Shelly owners face: after a few years, these devices become increasingly unreliable.

What looks like a Wi-Fi problem at first usually has a completely different cause. The good news: in most cases you can fix it yourself with a 50-cent repair!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The Problem: When Shellys Get Old

Recognizing the Typical Symptoms

Shelly 2.5 devices of the first generation in particular show characteristic problems after a few years:

Strange noises: Humming or buzzing from the device
Unstable Wi-Fi connection: Sporadic disconnects
Unreliable operation: Commands are not executed
Complete failure: The device stops responding entirely

In the video I demonstrate the characteristic sound — if your Shelly sounds like that, there is a good chance this repair will help!

The Root Cause: Capacitor Aging

What many people do not know: the problem is usually not the ESP8266 chip or the antenna, but a tiny electrolytic capacitor in the power supply. After years of use, it loses its electrical properties and destabilizes the entire power circuit.

The tricky part: the capacitor looks completely normal from the outside — no bulging, no visible damage.

The 50-Cent Repair, Step by Step

What You Need

100µF/16V electrolytic capacitor (approx. 50 cents)
Soldering iron and solder
Narrow flat-head screwdriver
Some patience and care

Important safety note: Never work on the Shelly while it is connected to mains power! What else to watch out for when opening mains devices is covered in Working safely with mains voltage.

Opening the Case — the Flat-Head Screwdriver Trick

Opening the Shelly 2.5 is a little tricky, but perfectly doable with the right approach. In the video I show you exactly:

Where to insert the flat-head screwdriver
How to carefully pry off the casing
What to watch out for with the delicate tabs

The trick is to work systematically along the sides without applying too much force.

Identifying the Faulty Capacitor

Once opened, you can see the compact circuit board with all its components. The problematic capacitor is the small black cylinder marked “100µF 16V”. In the video I explain exactly:

Where the capacitor is located
How to distinguish it from other components
What other capacitors are present on the board

Removing the Faulty Capacitor

Desoldering requires some skill, but is very manageable with the right technique. I show you in the video:

How to carefully tilt the capacitor out
The correct soldering iron technique
How to clear the holes after removal

Particularly important: the capacitor sits on the outer edge of the board and is therefore relatively easy to reach.

Installing the New Capacitor Correctly

With electrolytic capacitors, polarity is critical:

Negative pole: Marked with a broad stripe on the casing
Positive pole: The longer lead

In the video I show in detail how to correctly identify the polarity and orient the capacitor. Getting this wrong would destroy the entire device!

Reassembling the Case

When reassembling, make sure to route the Wi-Fi antenna correctly. There is a dedicated notch in the case for it — the video shows you exactly how this works.

The Success Test — Live in the Video

The most exciting moment: switching it on for the first time after the repair! In the video you can watch live:

How the repaired Shelly boots up
Testing the web interface
Checking the relay function
And most importantly: the listening test reveals complete silence!

After a successful repair, the Shelly runs reliably again – for how long, see my update.

Other Affected Shelly Models

The capacitor problem is not limited to the Shelly 2.5. Other models can be affected as well:

Shelly Dimmer (first generation)
Shelly 3EM (older versions)
Other first-generation Shellys

The repair principle remains the same — only the exact capacitor type may vary.

Why the Repair Is Worth It

Sustainability over the Throwaway Mindset

Instead of discarding working hardware and buying new devices, you invest 15 minutes and 50 cents in materials. That is:

Environmentally friendly: Less electronic waste
Cost-saving: A new Shelly 2.5 costs over 20 euros
Educational: You understand your hardware better

Long-Term Reliability

After the capacitor repair, the Shellys work like new again:

Stable Wi-Fi connection
No more strange noises
Reliable response to commands
More service life – though not permanently in my case (see update)

Practical Tips for the Future

Preventive Measures

Electrolytic capacitors age faster due to:

Heat: Avoid excessively warm installation locations
Moisture: Ensure a dry environment
Overvoltage: Use surge protection

When Is a Repair Worth Attempting?

The repair is most promising for:

Devices older than 2–3 years
Typical noise problems
Sporadic Wi-Fi dropouts
Devices that are still partially functional

Update September 2026: How long does the repair last?

A year after this article, I have to be honest: every Shelly 2.5 I repaired eventually failed again with the same defect. That’s why I’ve done this repair more than ten times in total.

And I didn’t use a cheap capacitor, but a Panasonic FR, 100 µF/16 V, 105 °C, low ESR (Reichelt: FR-A 100U 16B).

What I know now:

The Shelly 2.5 contains three electrolytic capacitors: the 100 µF/16 V one replaced here and two 4.7 µF/400 V – according to Hackaday, all from a budget brand. I only replaced the 100 µF capacitor. The community now recommends replacing all three with 105 °C brand-name parts no larger than the originals. Whether that makes the devices last for good, I can’t say.
The root cause remains: the device is very compact, the power supply parts sit close together, and it gets warm inside a closed wall box. A new capacitor doesn’t change that – even Hackaday expects another recap after a few years.
The Shelly 2.5 is technically outdated: no Bluetooth, no scripting, no Matter, no Zigbee, an ESP8266 with 2 MB flash. Its successors offer all of that.

My advice today: The repair is a good stopgap – for a few cents a dead device runs again until a replacement arrives. But if your Shelly 2.5 fails, you should seriously consider moving to a current generation. I’ve since replaced my last nine Shelly 2.5 with the Shelly 2PM Gen4.

More Hardware Repairs

This repair impressively demonstrates that smart home can be sustainable! The video shows not just the practical implementation, but also my thought process during troubleshooting.

More Repair Guides

Repairing a Sonoff S20 Smart Plug – the 26-Cent Fix – The same capacitor problem, different device: fixing Wi-Fi disconnects on the Sonoff S20
Replacing a Tablet Battery Yourself – Save Your Old Device in 20 Minutes! – When the tablet used as a smart home dashboard only works while plugged in

ESPHome Security Flaw: Critical CVE Hits All ESP32 Devices

Sun, 14 Sep 2025 00:00:00 +0200

A recently discovered security vulnerability in ESPHome 2025.8.0 affects ESP32 devices using the IDF Framework. The flaw allows attackers to bypass the built-in Basic Auth authentication and perform over-the-air updates without valid credentials.

This means: even if you have properly protected your ESPHome devices with a username and password, attackers can under certain circumstances still push firmware updates and gain control of the device.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Practical Demonstration of the Security Vulnerability

ESPHome as a Popular DIY Solution

ESPHome has established itself as one of the most popular solutions for DIY smart home projects. Its simple integration of ESP32 and ESP8266 controllers into the smart home makes it a widely used tool in the community.

However, the recently discovered security vulnerability shows that even established software can have unexpected weaknesses. In the video, I demonstrate the practical exploitation of this flaw on a test device.

Live Demonstration of the Vulnerability

In the video, I perform a controlled test in which I bypass the authentication of an ESP32 device. I use command-line tools to send an HTTP request with an empty Authorization header.

The result: the ESP32 device accepts the firmware update even though no valid credentials were transmitted. The web server responds with “Update successful,” confirming that Basic Auth authentication is not working correctly in this version.

Who Is Affected? The Technical Details

ESPHome Version 2025.8.0 in Focus

The security vulnerability primarily affects ESPHome version 2025.8.0, though the official vulnerability description also mentions “possibly older versions.” Particularly critical: the flaw exclusively affects ESP32 devices using the IDF Framework.

In the video, I explain exactly why this combination is problematic and how to find out whether your devices are affected.

ESP32 vs ESP8266: An Important Distinction

There is some good news: ESP8266 controllers are NOT affected by this vulnerability. If you exclusively use ESP8266-based devices, you can breathe a little easier for now.

That said, caution is warranted: most modern ESPHome projects use ESP32 controllers, since they are significantly more powerful and offer more features. These popular controllers are the ones affected by the flaw.

The Attack in Detail: How the Hack Works

The Authorization Header as the Entry Point

What you see in the video is the practical exploitation of a vulnerability in HTTP Basic Authentication. Normally, attackers need to transmit valid credentials in the Authorization header. The security vulnerability, however, allows this protection to be bypassed with an empty header.

The hack works via the /update endpoint, which is normally used for over-the-air updates. An attacker can submit manipulated firmware to this endpoint and have it installed without authentication.

Potential Impact of the Vulnerability

Since the security vulnerability allows arbitrary firmware to be flashed, various attack scenarios are conceivable. An attacker could theoretically:

Capture and exfiltrate sensor data
Use the device for further network scanning
Preserve the original functionality to remain undetected
Make modifications to the firmware

The practical impact depends heavily on the individual network configuration and the security measures already in place.

Immediate Protective Measures: What You Need to Do NOW

Step 1: Update ESPHome

The most important step: update your ESPHome installation to version 2025.8.1 or newer immediately. These versions contain the fix for the critical security vulnerability.

In the video, I show you exactly where to find the current version and how to perform the update.

Step 2: Reflash All ESP32 Devices

Even more important: you must reflash all your ESP32 devices with the updated ESPHome version. Updating the ESPHome software alone is not enough – the firmware on the devices themselves must be updated.

The easiest way to do this is via the “Update” button in the ESPHome management interface. In the video, you can see the complete process and learn what to watch out for.

Step 3: When in Doubt, Update

If you are unsure whether your devices are affected: an update never hurts. It is better to update one time too many than to have a compromised device on your network.

Assessing the Security Vulnerability

Trust in Authentication Mechanisms

ESPHome users typically rely on the built-in Basic Auth authentication to protect their devices. This security vulnerability shows that even well-established authentication mechanisms can contain bugs.

Many users run their ESP32 devices for extended periods without regular updates, since they are considered stable and reliable. However, this approach can become problematic when newly discovered security vulnerabilities emerge.

Security on the Home Network

A common assumption is that devices on the internal network are automatically protected. This vulnerability makes clear, however, that attackers with network access – for example via compromised devices or a guest Wi-Fi network – can exploit security flaws too.

In the video, I discuss the importance of regular updates even for internally operated devices.

Lessons from the Security Vulnerability

Updates Are Not Optional

This vulnerability underscores once again: regular updates are not a tiresome chore, but critical to the security of your smart home. Even well-established software like ESPHome can suddenly develop critical flaws.

Defense in Depth

A single layer of protection – no matter how well implemented – is not enough. The ESPHome vulnerability shows that even authentication can fail. Additional layers of protection such as network segmentation or VPN access can make the difference when it matters.

What You Will Learn in the Video

The video offers far more than just theoretical knowledge. You will see:

Live hack demonstration – understand the threat through a practical walkthrough
Step-by-step update guide – learn how to update your devices correctly
Technical background – understand why this vulnerability is so dangerous
Preventive security measures – protect yourself against future threats
Community discussion – find out how others are dealing with the problem

The practical demonstration in the video illustrates how the vulnerability works and shows concretely how the authentication can be bypassed. This helps in understanding the technical details and assessing the risk for your own installation.

Your Role in Smart Home Security

Community Responsibility

Security vulnerabilities like this affect not only you personally, but the entire smart home community. Share your knowledge, inform other users, and make sure this important information reaches the people affected.

A Proactive Security Stance

Use this security vulnerability as an opportunity to rethink your overall smart home security. Which other devices have not received updates in a long time? Which systems rely too heavily on a single layer of protection?

Conclusion: Security Requires Continuous Attention

The ESPHome security vulnerability underscores the importance of regular updates even for established software. It shows that even proven solutions can have unexpected weaknesses.

The video demonstrates the practical exploitation of the vulnerability and explains the necessary protective measures – from immediate updates to preventive security strategies.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

→ In a follow-up article, I analyzed the community’s reaction to this vulnerability and address the question of whether ESPHome is still justifiable: ESPHome After the Security Vulnerability: Irresponsible or Still Worth It?

Repairing the Sonoff S20 Smart Plug: The 26-Cent Fix

Sun, 07 Sep 2025 00:00:00 +0200

Sound familiar? Your Sonoff S20 smart plugs worked reliably for years, but suddenly they keep dropping their WiFi connection. A restart fixes things — for a few hours. Then the same thing happens all over again. You simply can’t build a reliable smart home on devices like that.

The good news: in most cases you can fix the problem yourself for under a dollar in parts. The secret lies in a tiny component that loses its electrical properties after a few years.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The Common Problem: Unstable WiFi Connection

Recognizing the Symptoms

The problem tends to show up in a very characteristic way:

The Sonoff S20 sporadically drops its WiFi connection
After a restart everything works again for minutes to hours
The device stops responding to commands from the app
The LED blinks irregularly or shows error states

The Root Cause: Capacitor Aging

What looks like a WiFi problem at first glance actually originates in the plug’s power supply. After some research it became clear: the electrolytic capacitors used in these devices lose their rated parameters after a few years.

This causes instability throughout the entire power supply circuit — instability that the ESP8266 microcontroller cannot handle. In the worst case the device eventually dies completely.

The $1 Repair: Step by Step

What You Need

One 330µF/16V electrolytic capacitor
A soldering iron and some solder
A Phillips screwdriver
Desoldering braid (helpful but optional)
Common sense when it comes to safety

Important safety notice: Never work on the plug while it is connected to mains power! What else to watch out for when opening mains devices is covered in Working safely with mains voltage.

Opening the Case

The Sonoff S20 is surprisingly easy to open. Remove four Phillips screws and you have access to the circuit board. The video shows you step by step exactly where the screws are located and how to open the case safely without damaging anything.

Identifying the Culprit

The problematic capacitors are easy to spot. They are the electrolytic capacitors in the power supply area of the board. The main suspect is the 330µF/16V capacitor located between two IC chips.

The tricky part: these capacitors look completely normal from the outside. No bulging, no visible damage — yet they are faulty. The video shows you exactly where to find the suspect capacitors and how to tell them apart from other components.

Removing the Faulty Capacitor

To replace the capacitor you need to partially loosen the board so you can reach the solder joints from the back. The relevant contacts sit between the two chips and need to be carefully desoldered.

The video shows the soldering iron work live, including tips for avoiding damage to the board. Clearing the holes after removing the old capacitor is covered in detail — that is the trickiest part of the whole repair.

Installing the New Capacitor

When inserting the new 330µF/16V electrolytic capacitor, polarity is critical:

Negative lead: Marked with a thick stripe
Positive lead: The other side (longer leg)

The board markings show you exactly which way the capacitor goes. Positive on top, negative on the bottom — following the markings on the board. The video demonstrates slowly and clearly how to identify the correct polarity and align the capacitor properly. Getting this wrong would destroy the entire power supply!

Reassembly

When reassembling, pay close attention to the correct positioning of the button. The small transparent plastic piece must sit precisely on its pins, otherwise the manual button will no longer work.

Also make sure the cables are routed so they do not conflict with the socket contacts. The video shows the small but important trick with the button — miss it and you will regret it later!

The Moment of Truth

After screwing everything back together comes the exciting part: the first power-up. If everything was done correctly, the LED starts blinking happily and the plug connects to the WiFi without any trouble.

The video shows the successful result live: the repaired Sonoff S20 is fully reachable at its IP address and switches flawlessly — something that was not possible before. That moment is genuinely satisfying and proves the effort was worth it.

Why the Repair Is Worth It

Sustainability Over Throwaway Culture

Instead of throwing away the “broken” plug and buying a new one, you invest about 30 minutes of time and under a dollar in parts. That is not only sustainable — it is also educational.

Other Affected Components

If replacing the first capacitor does not solve the problem, the other electrolytic capacitors in the circuit may also be affected. The repair principle stays the same.

Long-Term Stability

After the repair the plugs work perfectly again. The WiFi connection is stable, response times are fast, and reliability is back to its original level.

Practical Tips for the Future

Prevention

Electrolytic capacitors age due to heat and operating time. Avoid placing your Sonoff devices in excessively warm environments and ensure adequate ventilation.

When Is a Repair Worth It?

For devices older than 2–3 years that show the WiFi problems described above, a faulty capacitor is very likely the cause. The repair is usually successful and only takes a few minutes.

More Hardware Repair Projects Ahead

This repair shows impressively how sustainable smart home can be. Instead of discarding working hardware, we fix it with minimal effort. The best part: the video shows not just the repair itself but also the reasoning behind it — what to look for when diagnosing the fault and which pitfalls to avoid.

More Repair Guides

Fixing BROKEN Shellys – The 30-Cent Repair That Actually Works! – The same capacitor principle applied to the Shelly 2.5: solving WiFi problems with a new capacitor
Replace a Tablet Battery Yourself – Save Your Old Device in 20 Minutes! – When your old tablet needs to last hours instead of minutes as a smart home dashboard again

Home Assistant Remote Access: Securely Connect Anywhere

Sun, 31 Aug 2025 00:00:00 +0200

Picture this: you’re relaxing on the beach, the sun is shining, waves are rolling in — and suddenly you wonder: “Did I actually turn off the lights?” In the past, that thought would have left you uneasy for the rest of the day. Today, you simply pick up your phone, check Home Assistant, and see immediately: everything’s fine. The lights are off, the doors are locked, the alarm is armed. Welcome to the world of secure remote access!

But beware: the path to this convenience is paved with security traps that can turn your smart home into an open door for hackers. This video shows you how to balance comfort and security.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What Remote Access Really Means

The Invisible Bridge Between You and Your Home

Remote access to Home Assistant is like an invisible bridge between you and your home. Whether you’re at the office, on vacation, or just out shopping — this digital connection gives you access to all your smart home’s features at any time.

The key difference from local use: your data travels across the internet. That makes things both exciting and risky. The video gives you a clear picture of how the different connection methods work and where the dangers lurk.

Why Your Smart Home Needs Remote Access

A smart home without remote access is like a sports car without a road — technically impressive, but practically useless the moment you leave the house. Home Assistant’s true power only unfolds when you can reach it from anywhere.

Imagine getting a notification about unusual power consumption while you’re at work. Without remote access, you’re in the dark until you get home. With remote access, you can check immediately, identify the problem, and take action — potentially preventing serious damage.

The Four Ways Into Your Smart Home

Option 1: VPN — The Classic Secure Channel

VPN is like an armored tunnel through the wild internet. With solutions like WireGuard, Tailscale, or OpenVPN, you establish an encrypted connection to your home network. For your phone or laptop, it’s as if you were sitting right at home.

The big advantage: maximum security and full control over your data. The downside: setup can get a bit technical. The video walks you through the most important VPN options and helps you find the right one for you.

Option 2: Home Assistant Cloud — Simplicity at a Price

The Home Assistant Cloud from Nabu Casa is the premium option of remote access solutions: comfortable, reliable, and incredibly easy to set up. A few clicks, a monthly fee of around €5, and you’re ready to go.

What makes it special: no port forwarding required, no complex network configuration. Nabu Casa handles everything. At the same time, you’re supporting Home Assistant’s development, since the revenue flows directly back into the project.

Option 3: Reverse Proxy — For the Tech Enthusiasts

A reverse proxy like Cloudflare Tunnel is the solution for those who like to tinker while still wanting professional-grade security. It becomes particularly compelling in combination with Cloudflare Access, an authentication layer that adds an extra line of defense.

This approach offers maximum flexibility and can be run for free. The setup effort, however, should not be underestimated. The video gives you an overview and points you to a detailed Cloudflare tutorial.

The Path to Disaster: Direct Port Forwarding

There is a fourth option — one I’m mentioning only to warn you against it: direct port forwarding without additional protection. That’s like leaving your front door wide open with a sign that says: “Smart home owner lives here!”

Hackers constantly scan the internet for exactly these kinds of open doors. An unprotected open port is an open invitation for attackers. For more on this topic — and how to do it right — check out my separate video on secure port forwarding.

The Most Common Pitfalls and How to Avoid Them

Pitfall 1: Weak Authentication

“123456” or “password” may be easy to remember, but they’re just as easy to crack. When accessing your smart home remotely, a strong, unique password isn’t optional — it’s mandatory.

Even better: enable two-factor authentication (2FA). Even if an attacker gets hold of your password, they can’t get in without the second factor. The video shows you how to enable and properly use 2FA in Home Assistant.

Pitfall 2: Missing Access Restrictions

Not everyone should be able to access your smart home from anywhere. IP allowlists let you limit access to known locations. Role-based permissions ensure that guests can only see what they’re supposed to see.

These techniques are more powerful than they might seem at first. The video walks you through practical examples and explains how to make the most of these security features.

Pitfall 3: Unencrypted Connections

HTTP is like sending a postcard — anyone can read it. HTTPS is like a sealed letter. When accessing your smart home remotely, always use encrypted connections, regardless of which method you choose.

Creative Uses for Your Remote Access

Smart Heating Control

Imagine you’re returning from vacation earlier than planned. Instead of coming home to a cold apartment, you start the heating from the highway. By the time you arrive, it’s comfortably warm — without wasting energy in the meantime.

Smart Doorbell Monitoring

Expecting a package but still at work? With remote access, you’ll see immediately when someone rings the doorbell. You can talk to the delivery driver, tell them where to leave the package, or even unlock the door if you trust them.

Garage Door Timing

This is one of my favorite use cases: you open the garage door from your car while you’re still two streets away. By the time you arrive, the door is already open and you can drive straight in without stopping. A small convenience that meaningfully improves everyday life.

The video shows these use cases in action and gives you ideas for your own creative solutions.

Why You Should Watch the Video

This article gives you a solid overview of remote access options. But the video shows you the practical implementation. You’ll see:

Live demonstrations of the different remote access methods
Step-by-step guides for setup
Security checklists to work through
Real-world examples of creative use cases
Troubleshooting tips for common issues

Particularly valuable are the security notes that are hard to convey in article form. In the video, you’ll see concretely what to watch out for and how to avoid typical beginner mistakes.

The Home Assistant A–Z Series

This video is part of the “Home Assistant A to Z” series — a systematic introduction to all the important aspects of Home Assistant. Each video stands on its own and can be digested in about 5 minutes.

Whether you’re just getting started or already have experience: this series is guaranteed to offer new tips and tricks. Remote access is a particularly important piece of the puzzle, because it transforms your local smart home into a truly flexible system.

Conclusion: Security Before Convenience

Remote access to Home Assistant isn’t a luxury — it’s a necessity for a modern smart home. But as with all powerful tools: with great power comes great responsibility.

The video shows you how to handle that responsibility correctly. You’ll learn not just how remote access works, but how to implement it securely. Because in the end, the best remote access solution is worthless if it turns your home into an open door for attackers.

Home Assistant AI Automations: How Dangerous Are They?

Sun, 24 Aug 2025 00:00:00 +0200

It felt like an early Christmas gift: Home Assistant 2025.8 finally promises real AI support for your automations. Imagine being able to press a button and have artificial intelligence suggest perfect names for all your automations. Sounds like a dream, right?

But sometimes the most beautiful dreams turn into nightmares. What looks like a breakthrough at first glance can turn your carefully built smart home into a chaotic naming mess — and the tricky part is you won’t notice until it’s too late.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

When Progress Becomes Regression

The Tempting Promise of the AI Suggest Feature

You probably know the feeling: you’ve just built a brilliant new automation and you’re staring at the infamous name field. “Automation 47” would be honest, but not particularly helpful. That’s where the new “Suggest” feature in Home Assistant 2025.8 seems to come to the rescue. One click, and the AI proposes a name. Magic? Almost.

What happens in the background is genuinely impressive: Home Assistant doesn’t just send the YAML code of your current automation to the AI model — it also sends the names of all your existing automations. In theory, the AI has everything it needs to align with your existing naming scheme.

But this is where the trouble begins. In the video, I show exactly what happens when the AI encounters a typical “organically grown” smart home — and why the result is often disastrous.

The Great Naming Dilemma

Imagine spending weeks desperately searching for a specific automation in your list of hundreds. Was it “Blinds down”, “Close shutters”, or “Rolladen automatisch”? Or maybe “Jalousie runter”?

The truth is: most of us haven’t been consistent when naming our automations. Sometimes German, sometimes English, sometimes verbose, sometimes terse. The AI can only work with what you give it — and if your existing names are a hodgepodge, it will only amplify that chaos.

Why This Seemingly Harmless Feature Can Ruin Your Smart Home

The insidious thing about the new Suggest feature isn’t what it does — it’s what it can’t do. It can’t read your mind. While you might have a sophisticated naming scheme in your head (“Room_Device_Action” or similar), that knowledge is invisible to the AI.

The result? A gradual decay of your automation structure. Today the AI suggests “Living room light on”, tomorrow “Activate kitchen lighting”, and the day after “Turn on bedroom lights”. Within a few weeks you have a Babylonian language muddle that makes your smart home practically unusable.

In the video, I demonstrate this using a real installation with over 100 automations — the result is both alarming and instructive.

The Solution: How to Use AI the Right Way

The Game-Changer: Batch Processing Instead of One-at-a-Time

But there is hope! The problem isn’t AI itself — it’s the way it’s being used. What if you didn’t have to process each automation individually, but could make your entire installation consistent in one go?

That’s exactly what I show in the video. The trick is simple yet incredibly effective: instead of letting the AI work on automations one by one, you hand it all your automations at once — together with precise instructions about what the perfect naming scheme should look like.

The Secret Is in the Details

What the Home Assistant feature can’t do, you do manually: you give the AI a crystal-clear assignment. Not “do something sensible”, but “use exclusively German terms, apply the scheme Room_Device_Action, and follow these examples”.

In the video you can see how I implement exactly that — from extracting automations.yaml to feeding the perfectly renamed automations back in. The process is simpler than you think, but the impact is dramatic.

Why Reasoning-Capable AI Models Make the Difference

Things get particularly interesting with large installations. While basic AI models quickly lose the overview, reasoning-capable models like GPT-5 Thinking can identify relationships and develop consistent patterns.

The video shows impressively how the AI doesn’t just assign names — it develops a well-thought-out system. Similar automations are grouped recognizably, edge cases are handled intelligently, and in the end you have an installation that looks as if a professional had planned it from the start.

The Step-by-Step Path to Perfection

The video walks you through the complete process — and I promise it’s simpler than you think:

Step 1: Take Stock

First, download your automations.yaml from your Home Assistant installation. This file contains all your automations in YAML format — essentially the blueprint of your smart home.

Step 2: Choose the Right AI

Not every AI is suited for this task. In the video I explain why I use GPT-5 Thinking and why reasoning-capable models deliver significantly better results for complex naming tasks.

Step 3: The Perfect Prompt

This is where the real difference is made. I show you my tested prompt that turns chaotic automation names into a perfectly structured list. You can watch the AI work and make decisions in real time. The prompt is available to copy in the video description on YouTube — just click into the video above.

Step 4: Patience

While the AI is working, it’s a great time to follow the channel — especially if AI in the context of smart home interests you. This may be my first video on the topic, but it certainly won’t be the last.

Step 5: The Result

The outcome is impressive. What was a jumble of different naming styles becomes a clean, coherent structure. Every automation has its perfect place, similar functions are instantly recognizable, and navigation becomes effortless.

Step 6: Feed It Back

The final step is importing the result back into Home Assistant. A quick restart via the Developer Tools, and your installation shines in a whole new light.

The Outcome: From Chaos to Order

What you see in the video is more than a technical demonstration. It’s the transformation of an organically grown, chaotic installation into a professionally structured smart home.

The before-and-after views speak for themselves: where “Automation 17”, “Kitchen lights on”, “Licht Wohnzimmer”, and “Beleuchtung_Schlafzimmer_automatisch” once sat side by side, you now find a crystal-clear structure.

The Long-Term Benefits

After the transformation you get:

Lightning-fast navigation — you find every automation instantly
Easy maintenance — similar automations are logically grouped together
Professional appearance — the system becomes understandable for other family members too
Future-proofing — new automations automatically follow the established scheme

The Ultimate Flexibility Bonus

The best part of this approach is what I show at the end of the video: total flexibility. Not happy with the new scheme after a few weeks? No problem — just adjust the prompt and run the process again.

No more manually renaming hundreds of automations. No more hours of clicking. Simply change the prompt, let the AI work, done. This flexibility is the real game-changer.

What to Expect in the Video

The video is a complete hands-on guide with no boring theory. You’ll see:

Live demonstration of the problematic Suggest feature
Step-by-step guide for the better approach
Real before-and-after comparisons from a 100+ automation installation
The exact prompt I use
Tips on choosing the right AI model for best results
Pitfalls and how to avoid them

This isn’t theoretical — it’s pure practice. You can start immediately and apply the method to your own installation.

Why You Should Watch the Video

This article gives you a solid overview, but the video shows you the magic in action. Watching a chaotic mess of automation names transform into a perfectly structured list is simply fascinating.

You’ll also get insights in the video that are hard to convey in writing:

How the AI “thinks” and makes decisions
Which naming patterns work particularly well
How to handle edge cases and exceptions
Why some AI models deliver better results than others

Conclusion: The Difference Between Using AI and Using AI Correctly

The new Suggest feature in Home Assistant 2025.8 is a bold first step toward AI integration. But as is often the case with new technology: the first attempt is rarely the best.

The video doesn’t just point out the weaknesses of the current implementation — it gives you a concrete, immediately actionable alternative. One that not only works better, but is also more flexible and future-proof.

The takeaway? AI is a powerful tool — but only if you know how to use it correctly. The Home Assistant Suggest feature is like using a hammer as a scalpel. It sort of works, but the result is rarely satisfying.

With the approach from the video, you have a precision instrument instead. A tool that makes your smart home not just nicer, but more professional and maintainable.

Watch the video, try it yourself, and let the results surprise you. Your automations — and your future self — will thank you.

Have you had any experiences with the new AI feature? And what other use cases for AI in Home Assistant do you see? Feel free to leave a comment — I’m curious to hear your ideas!

Home Assistant A-Z: E is for Entities

Sun, 17 Aug 2025 00:00:00 +0200

Every Home Assistant user works with them daily – often without knowing exactly what’s behind them: entities are the foundation of your smart home. The better you understand and name them, the more efficient, robust, and manageable your system becomes.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What exactly is an entity?

In Home Assistant, an entity is the smallest unit of information you can work with. Every light, sensor, or switch is an entity – often several per device. A room sensor, for example, has one entity for the current air temperature and another for humidity.

Each entity has a unique technical ID (entity_id). It consists of a prefix for the entity type – e.g. light, sensor, or switch – followed by a freely chosen identifier that typically describes the room and function. Examples:

light.living_room
sensor.bedroom_temperature

An entity holds a current state (e.g. “on/off” or “21.5 °C”) and often attributes such as battery level, signal quality, or manufacturer. Beyond classic devices, there are also helper entities like automations, scripts, or template entities that you derive from existing values.

Why does this matter for your smart home?

Without entities, nothing works in Home Assistant. Automations need entities as triggers and targets, dashboards display entities, scripts read and set states. Clean naming and structure help you:

find what you’re looking for faster,
avoid mistakes, and
keep your system maintainable in the long run – even when devices are replaced.

How does it work in practice?

You’ll find all entities here: Settings → Devices & Services → Entities. There you can search, filter, rename, or disable them. You also see which integration an entity comes from and which device it belongs to.

Recommended naming convention: Use consistent, short IDs following the pattern area_device_function, e.g. living_room_lamp_left or bedroom_temperature. Stick to one language (German or English) and avoid cryptic abbreviations. UI display names can be friendly and readable (“Left Living Room Lamp”), while the entity_id stays technical and concise.

Template entities: Derive new information from existing data (e.g. “washing machine running”) and assign them to the appropriate device. This keeps related entities grouped and your overview clean (Edit entity → Assigned device).

The most common pitfalls

Invalid entity IDs. Only lowercase letters, numbers, and underscores are allowed; no underscores at the start or end. Incorrect IDs (e.g. when editing YAML) cause error messages or “nothing happens”.

Good: sensor.office_co2
Bad: Sensor.Office-CO2

Orphaned or duplicate entities. After replacing devices, old IDs often remain as …_2 or show as “unavailable”. Filter, disable, or delete them so nothing triggers twice and search results stay clean.
Binding automations to devices instead of entities. Convenient – but things break when a device is replaced. Better: Always use entity_id in automations. Give the new device the same entity_id and all automations keep working.
Ignoring attributes. Many useful pieces of information are stored as attributes in entities (e.g. battery level, RSSI). Use them in templates, alerts, or notifications (e.g. “Battery below 15%”).
Inconsistent naming. Mixing languages or naming schemes makes searching and maintaining automations harder. One scheme, one language – stick to it.

Creative and useful things you can do with entities

Derive device status from power consumption: Calculate a washing machine status entity from the power draw of a smart plug and send a notification when the laundry is done.
Warning and overview dashboards: Use an Entity Filter card to show only problem cases (e.g. open windows/doors, low batteries). Combined with color highlighting, you won’t miss anything important. More on this in “D is for Dashboard”.
“Unavailable” watchdog: Build a template sensor that monitors the unavailable state of critical entities and sends a central alert.

Summary

Entities are the backbone of your smart home. Anyone who understands, cleanly names, groups, and maintains them saves time, avoids mistakes, and makes automations more robust – today and when the next device swap comes around.

What naming convention do you use for your entities? Share your approach in the comments! Coming up next: “F” is for Remote Access, or check out the overview of all A–Z posts.

Home Assistant A-Z: D is for Dashboard

Sun, 10 Aug 2025 00:00:00 +0200

You open Home Assistant and see… a chaotic mess of switches, sensors, and cryptic names? Or worse: you miss important warnings because everything looks grey and unremarkable? It doesn’t have to be this way! A well-designed dashboard makes the difference between frustration and joy in your daily smart home experience.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What is it, anyway?

The dashboard is your central control panel in the smart home – the first screen you see when you open the app or web interface. This is where you control your devices, monitor sensors, and keep an overview of your smart home.

A dashboard is made up of cards – small widgets that display different information. You can add light switches, temperature readouts, camera streams, or complex charts. Think of it like the home screen of your smartphone, but for your home.

The default dashboard automatically shows all your devices, but that gets cluttered fast. That’s why you can create your own dashboards – one for the living room, one for security, or one for energy monitoring. Anything is possible.

Why does this matter for your smart home?

Let’s be honest: the best smart home is useless if you can’t find your way around it. A well-thought-out dashboard saves you time and frustration every day. Instead of scrolling through endless lists, you see the most important information at a glance.

A practical example: in the morning, quickly check whether all windows are closed, the heating is set correctly, and whether the coffee maker is already running. With a personalized “Good Morning” dashboard, that takes 5 seconds instead of 2 minutes.

But even more importantly: a good dashboard warns you about problems! Imagine your fridge is too warm, your plants need water, or a door has been left open. With color-coded warnings, you’ll never miss something like that again. Red cards for critical errors, orange for warnings, blue for notices – you can see at a glance where action is needed.

How does it work in Home Assistant?

Let’s look at this practically: go to your dashboard and click the pencil icon in the top right. Now you can add, move, or delete cards. It’s all very intuitive.

For starters, I recommend: create a new dashboard via “Settings” → “Dashboards” → “Add Dashboard”. Then add the entities that matter most to you. Over time, you’ll notice what you use frequently and what you don’t. Take a critical look at your dashboard once a week and refine it step by step. Dashboards are as individual as each user – it just needs to work for you, and you know that best yourself.

One tip: make use of the ability to only show entities when relevant. You can do this with an Entity Filter card, or via the visibility conditions in the card settings. This keeps your overview clean.

A concrete example: add an Entities card for an open window, but only show it when the window is actually open.

Tip: With card-mod from the Home Assistant Community Store, you can make warnings color-coded: red backgrounds for critical errors, orange for warnings. You’ll never overlook anything important again. Curious? I’ve linked a video above and in the video description.

The most common pitfalls

The first pitfall: overloading your dashboard with everything that’s possible. Just because you have 50 sensors doesn’t mean they all need to be on the home screen. The result: nobody can find anything, and important warnings get lost in the noise. My tip: only show what you genuinely need every day.

Second pitfall: no differentiation. When everything looks the same, you can’t tell what’s urgent. Use a system: red for critical errors like “fridge too warm”, orange for warnings like “battery low”, blue for notices like “take out the trash”. That way you immediately see what matters.

Third pitfall: only testing on the desktop. Many people design their dashboard on a computer and then wonder why it looks off on their phone. Always test your dashboard on mobile too – especially warning cards need to be clearly visible on the go. Home Assistant makes this easy: as soon as you change a dashboard, any phone with the app open in parallel will prompt you to reload. So you can test your changes live right away.

What creative or useful things can you do with it?

Dashboards can do much more than just display switches. My favorite: a “Warnings Dashboard” using Entity Filter cards that only appear when there’s a problem – red cards for critical errors, orange for warnings, blue for notices. Forgotten plants, open doors, or weak batteries will never slip past you again.

I’ve put together more tips and tricks in this video – I’ve also linked it in the video description.

Next up is “E” is for Entities, or check out the overview of all A-Z posts.

Home Assistant A-Z: C is for Cloud Integrations

Sun, 03 Aug 2025 00:00:00 +0200

Did you know that some Home Assistant integrations can pose real security risks? While you think your smart home is secure, cloud integrations may be sending your most private data to remote servers somewhere on the internet. Today I’ll show you what to watch out for.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What exactly is this?

Cloud integrations are Home Assistant integrations that communicate with external servers over the internet. Imagine this: your motion sensor detects movement, but instead of switching your light directly, it first sends that information to a server somewhere in the world — and that server then sends the signal back.

Typical examples are Google Nest, Amazon Alexa, or Ring cameras. These devices require an active internet connection to function.

The opposite are local integrations: everything stays within your home network. Zigbee devices or ESPHome sensors communicate directly with your Home Assistant — no detour over the internet.

Why does this matter for your smart home?

Let’s be honest: cloud integrations are convenient. You can access your devices from anywhere and often benefit from advanced features like voice control. But they also carry risks.

Imagine your Ring camera gets hacked and strangers are watching into your bedroom. Or the manufacturer shuts down their servers and your €500 devices become expensive e-waste — exactly what happened in 2016 with Google’s Revolv Smart Home Hub.

Local integrations, on the other hand, work even without internet, are faster, and your data stays 100% with you. A Zigbee light switch responds within milliseconds — cloud devices often take 100 milliseconds or more. That might sound negligible, but it gets annoying quickly in everyday use.

How does this work in Home Assistant?

How do you recognize cloud integrations in Home Assistant? It’s actually quite simple: look up the integration on the Home Assistant website. There you’ll find what’s called the “IoT Class”. If it says “Cloud Push” or “Cloud Polling”, it’s a cloud integration.

When you install an integration, ask yourself: do I need to sign in with an online account? Does the device need internet to work? If yes, it’s likely a cloud integration.

The most common pitfalls

The first pitfall: blindly trusting cloud integrations. A stark example is Ring cameras: hackers gained access and were able to watch live, speak to residents, and even frighten children. The problem: weak passwords and missing two-factor authentication. Always use strong, unique passwords and enable 2FA wherever possible.

The second pitfall: ignoring vendor lock-in. If Google, Amazon, or other providers change their business strategy, you’re left with worthless hardware. My tip: before every purchase, check whether a local alternative exists. Local devices are often cheaper and more reliable.

The third pitfall: mixing cloud and local devices without network separation. A compromised cloud camera can serve as an entry point into your entire home network. Use a separate guest network for cloud devices, or a firewall to isolate them. There’s more on this topic in another video (add video link in YouTube).

What can you do creatively or practically with this?

My clear recommendation: use cloud integrations only when truly necessary. For voice control with Alexa or Google — fine. But for simple sensors or switches, there’s almost always a local alternative.

If you do use cloud integrations, secure them properly: strong passwords, regular updates, separate network.

My personal favorites: ESPHome for self-built sensors and Zigbee for off-the-shelf devices. Both work completely locally, are affordable, and absolutely reliable.

Next up is “D” is for Dashboard, or take a look at the overview of all A-Z posts.

Home Assistant A-Z: B is for Blueprints

Sun, 27 Jul 2025 00:00:00 +0200

Imagine being able to install complex automations with a single click — pre-configured, tested, and ready to go. Sounds too good to be true? That’s exactly the idea behind Home Assistant Blueprints!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What are Blueprints, exactly?

Blueprints are pre-built automation templates for Home Assistant. Imagine someone has already created the perfect automation — for motion sensors, notifications, or complex lighting controls — and you can simply adopt it.

The concept is brilliantly simple: a Blueprint defines the logic of an automation, but leaves the specific devices and settings up to you. You import the Blueprint, select your own sensors and switches, and the automation is up and running.

For example: a Blueprint for “light on motion” works with any motion sensor and any light — you just pick your specific devices. The entire logic is already programmed and tested.

Why does this matter for your smart home?

Let’s be honest: building automations from scratch can get complicated. Especially for advanced scenarios like “dim lights based on time of day and presence” or “send a notification only under certain conditions.” With Blueprints, you skip all that development work.

In practice, this means: instead of tinkering for hours, you install a Blueprint in 2 minutes. The automation runs immediately and has already been tested by other users in real-world setups.

How does it work in Home Assistant?

Let’s take a concrete look. To use a Blueprint, go to Settings → Automations & Scenes, then Blueprints, and click “Import Blueprint.”

You can find Blueprints in several ways: in the official Home Assistant Community (linked directly in the import dialog), on GitHub, or in other forums. Just copy the Blueprint URL and paste it into Home Assistant.

After importing, the Blueprint appears in your list of available Blueprints and you can use it right away. Important: you can use a single Blueprint multiple times — for example, with different configurations. You might use the same motion-light Blueprint for the hallway and for the bathroom. You create two separate automations, both using the same Blueprint, but with different sensors and lights.

The most common pitfalls

A frequent mistake is trusting a Blueprint blindly without understanding it. Sure, it’s quick — but even if you’re saving time by not building the automation from scratch, you should still take a moment to understand what the Blueprint does. Without understanding its structure, you’ll be stuck if something stops working. And strictly speaking, a poorly written Blueprint could even execute things in your home that you never intended.

The second pitfall: using outdated or poorly documented Blueprints. Not every Blueprint on the internet is well-maintained. Some only work with older versions of Home Assistant; others have hidden bugs. Always check the ratings, comments, and the last update date. Blueprints from the official Home Assistant Community are generally the safest choice.

One last common mistake: installing too many Blueprints at once without properly testing them. Each Blueprint creates new automations in your system. If multiple Blueprints have similar functionality — for example, different lighting controls — they can interfere with each other. Install one Blueprint at a time and test thoroughly before moving on. It will save your nerves and prevent frustration.

What can you do with Blueprints creatively or practically?

Blueprints open up an enormous world of possibilities without requiring you to program sophisticated logic yourself. But it also works the other way around: you can create your own Blueprints to standardize similar automations. If you have a lighting automation for multiple rooms, there’s a good chance they all work largely the same way. Why not turn it into a Blueprint and simply configure the sensors and lights per room? That saves you effort in the long run when maintaining your automations.

Which Blueprint would you start with? Share your idea in the comments below.

Next up is “C” for Cloud Integrations, or check out the overview of all A-Z posts.

Home Assistant A-Z: A is for Automations

Sun, 20 Jul 2025 00:00:00 +0200

Every day you flip a light switch at least 50 times. What if your home could take care of that for you — and save energy, improve your security, and give you back 15 minutes every single day?

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What is this actually about?

Automations are the heart of your smart home. They handle tasks for you — automatically, of course.

The concept: If something happens, then do something.

When it gets dark outside, turn on the outdoor lighting
When nobody is home, arm the alarm system

You need a trigger (e.g., sunset), can narrow things down with conditions (e.g., only when nobody is home), and define one or more actions (e.g., turn on the lights).

Why does this matter for your smart home?

Let’s be honest: you can control your lights via an app. But imagine coming home exhausted, arms full of grocery bags — and the lights just turn on automatically. Or you forget the stove again — an automation shuts it off after 30 minutes.

Benefits:

Time savings: No opening apps, no searching for switches, no forgotten devices
Security: Automatic shutoffs, notifications, and presence simulations
Convenience: Your home thinks ahead and takes care of routine tasks for you

My three most important automations easily save me 15 minutes a day!

How does this work in Home Assistant?

Let’s look at an example:

Trigger: Wind sensor reports gusts above 30 km/h
Action: Automatically retract the awning

Here’s how:

Go to Settings → Automations & Scenes
Click Create Automation
Select Start with an empty automation
Define triggers, conditions, and actions
Name and save the automation

The most common pitfalls

1. Not accounting for all real-life situations The awning retracts when it’s windy — but what happens when you manually extend it again afterwards? The automation won’t fire because it only triggers when wind speed crosses the threshold. Solution: Add additional triggers or conditions to handle edge cases.

2. Problems with multiple triggers If you use multiple triggers (e.g., “Wind gusts OR awning is extended”), the automation can fire even when you intentionally extend the awning yourself. Solution: When using multiple triggers, always use conditions to verify that the actual condition is still met.

3. Wrong automation mode The default mode “Single” means: if the automation is triggered again while it’s still running, nothing happens. This can be problematic for longer-running automations. Solution: Choose the right mode (Single, Restart, Parallel, Queue) depending on your use case. Learn more in this article.

What creative or useful things can you do with this?

With automations, the possibilities are almost endless. For real value, start with automations that eliminate repetitive manual tasks.

My favorite: “Good Morning” automation

Open the roller shutters
Set the lights in the bathroom and kitchen
Start music depending on the day of the week

So many things I’d otherwise have to do by hand every single day!

Conclusion

Automations make the difference between a connected home and a truly smart home. They save time, improve security, and simply make life more comfortable.

My tip: Start small, test thoroughly, and expand your automations step by step. You’ll soon wonder how you ever lived without them!

Which automation saves you the most time? Share your idea in the comments below. Continue with “B” is for Blueprints or check out the overview of all A-Z articles.

The Perfect Home Assistant Password

Sun, 13 Jul 2025 00:00:00 +0200

Imagine it’s the middle of the night and suddenly your smart speaker blasts music at full volume. The lights are flashing like crazy, and your heating turns itself up to maximum. At first you think it’s a technical glitch — but then you realize: someone else has taken control of your smart home!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What sounds like a horror scenario isn’t actually that far-fetched. Users in the Home Assistant forum have shared their experiences:

A user reported in 2018 that their system was controlling lights without authorization — they had Home Assistant running with an open HTTP port and no password
Another case from January 2025: Immediate and massive login attacks right after opening the default port 8123

The alarming reality: According to recent studies, over 80% of all successful cyberattacks are attributed to weak or reused passwords (source: World Economic Forum/LastPass, 2023). Using services like Shodan, attackers find open smart home instances within seconds. The result: someone connects to your Home Assistant installation and — at best — just plays a prank like this.

That’s why a strong password for Home Assistant is absolutely critical. Unfortunately, many people still use trivial passwords that are easy to remember but just as easy to guess. And here’s what makes Home Assistant special: there is no built-in password policy. No requirements for how long or complex your password must be.

A serious mistake? On the contrary! I’ll explain why this is actually a good thing — and why the perfect Home Assistant password isn’t the same for everyone.

What Makes a Good Password?

You’ve probably rolled your eyes more than once when a site demanded “at least 8 characters, one uppercase letter, one number, and a special character.” Many people assume a password is automatically secure just because it looks complicated — but that’s not quite right. What really matters is entropy — how unpredictable and extensive the character combination is. And the rule here is: length beats complexity.

A long password with 20 characters is generally far more secure than a short one with 8, even if the shorter one contains every possible special character. Why? Because each additional character exponentially increases the number of possible combinations — and that’s worth more than a wide variety of character types.

A practical example:

Home123! dutifully meets all complexity rules and looks “secure” at first glance
In reality, many people follow exactly this pattern — a word with a capital letter, the number sequence 123, and an exclamation mark at the end
Passwords like this can be cracked very quickly or guessed through dictionary attacks
myhomeassistantisawesome would take years to crack, even though it uses only lowercase letters

➡️ Test it yourself: howsecureismypassword.net

Sources:

NIST SP 800‑63B (PDF) – See Section 5.1.1.2: No more mandatory regular password changes + focus on length over complexity.
NCSC: Problems forcing regular password expiry – Warns against cyclic password changes as they lead to predictable patterns.
The Guardian: Rejoice! The charade of having to change our passwords every few months is coming to an end – Reports on NIST & NCSC guidelines against frequent password changes and in favor of passphrases.

The Problem with Password Policies

Those seemingly “complicated” passwords can actually end up being insecure because they follow predictable patterns. Strict password policies often mislead users and tempt them into reusing passwords. Be honest: when you had to fight your way through an annoying password policy, didn’t you just reach for your standard password that ticks all the boxes?

You’re not alone — the numbers are alarmingly clear:

89% know that password reuse is risky, but only 12% use a unique password for every account (source: Spacelift, 2025)
62% of US users report frequently or always reusing passwords (source: NordPass, April 2025)
Especially striking for Gen Z: 72% reuse passwords even though 79% know the risk (source: Bitwarden World Password Day, 2025)
Even after data breaches, 59% of Gen Z recycle their passwords (source: HelpNetSecurity, May 2025)

This is a genuine internal conflict: we know what’s right, but act differently out of convenience or habit. Experts call this a cognitive dissonance between knowledge and behavior.

The Better Alternative: Passphrases

Current recommendations are clear: forget complexity requirements — what counts is length and uniqueness.

In plain terms: use a long passphrase you can actually remember, rather than cryptic eight-character gibberish. You may know the famous xkcd comic on this — four simple words like “correct horse battery staple” together form a nearly uncrackable password that you can still remember fairly easily.

What matters:

Length
Randomness
Uniqueness

Every additional character makes your password exponentially stronger. And of course it shouldn’t be a known word or pattern — “Password123!” is long and looks complex, but it’s still guessed quickly.

Specifics for Home Assistant

Let’s get concrete about Home Assistant: what role do passwords actually play here? Home Assistant is your self-hosted smart home hub. You set up user accounts and assign passwords for logging into the web frontend — and with that, full access to all devices connected to your Home Assistant.

Important: Home Assistant does not dictate what your passwords should look like. There’s no minimum length, no special character requirement, nothing of the sort. And that’s intentional. There used to be a warning when a password was too short. These warnings no longer exist — the developers realized it wasn’t productive. Why?

The requirements for a password depend heavily on the specific use case:

When I record videos for this channel, I’m always glad I don’t have to set a complex password for Home Assistant test instances
Someone who never exposes their smart home to the internet and has no guests on their home network can afford lower password requirements
A Home Assistant installation that is publicly accessible on the internet is subject to completely different standards

With Home Assistant, you are the administrator and must take responsibility yourself. If you’re not comfortable with that, a password manager is probably the best choice for you.

The moment your system is online, it becomes a potential target for automated attacks. And then things get serious fast. Home Assistant does have a built-in brute-force defense (Wikipedia article): after a certain number of failed login attempts, the user’s IP address is temporarily blocked. That’s helpful, but not a cure-all:

Many attackers simply spread their attempts across many different IP addresses
A weak password is often guessed after just a few tries
The IP block therefore offers only limited protection

Additional risks: Even Home Assistant with Nabu Casa has had critical security vulnerabilities — in 2023, a flaw (CVE-2023-27482) with the highest severity score of 10/10 was disclosed, enabling an authentication bypass.

➡️ More on securing Home Assistant: Home Assistant absichern: 5 Tipps für mehr Sicherheit

➡️ Why port forwarding is problematic: Portfreigaben vermeiden: So geht sicherer Fernzugriff

Conclusion

There is no single perfect Home Assistant password — it depends on your use case. But the numbers speak clearly: over 80% of all cyberattacks succeed through weak or reused passwords. At the same time, 89% of people know the risk, yet only 12% act consistently.

What matters:

Length over complexity: A long password is better than a short complex one
Uniqueness: Every system gets its own password — no exceptions!
Proportionality: Match your security requirements to your setup
Additional measures: When internet-facing, use 2FA and secure connections
Use a password manager: This breaks the cycle of password reuse

The solution is simple: A long passphrase or a password manager. That puts you in the 12% who do it right — rather than the 62% who accept security risks out of convenience.

Home Assistant gets it right by putting the responsibility in your hands. Use that freedom wisely!

A look ahead: The next generation of authentication is passkeys — a passwordless technology based on cryptographic keys that is significantly more secure than traditional passwords. Unfortunately, Home Assistant does not yet support passkeys, but the future of authentication may well head in that direction. Until then, strong, unique passwords and 2FA remain our best defense.

BSI Tips Explained: How to Properly Secure Your Smart Home

Sun, 06 Jul 2025 00:00:00 +0200

Who voluntarily reads through the lengthy publications of Germany’s Federal Office for Information Security (BSI)? I did it for you and distilled the most important tips for your smart home – explained clearly, assessed critically, and backed up with real-world examples, just like in the video!

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Introduction: Who Actually Reads the BSI?

The BSI publishes a lot of solid advice on how to secure your smart home. But honestly – who willingly reads through pages of text on a government website? That’s why you’ll find the most important recommendations here, explained in plain language and put into perspective.

➡️ You can find the official BSI recommendations here: BSI Smart Home Tips

1. Choose Strong Passwords

It sounds obvious, but weak passwords are one of the most common entry points for attacks. Many users simply leave the default password in place – “admin”, “123456”, or even no password at all are unfortunately far from rare. The BSI advises: no real words, no simple number sequences or keyboard patterns. My tip: use a unique, strong password for every device, ideally managed with a password manager like KeePass or Bitwarden. It keeps things both easy and secure.

2. Keep Software Up to Date

Updates patch security vulnerabilities. Enable automatic updates wherever possible. Not every device offers this – in that case, there’s only one option: check manually on a regular basis, for example once a month. If a device hasn’t received updates in years, you should consider replacing it. Pay attention to the manufacturer’s update policy before you buy!

➡️ To see what can happen when devices stop receiving updates, check out the video about a robot vacuum with a security flaw: Robot Vacuum Hack: This Is How Easy Access Is!

3. Secure Your Router & Home Network

Your router is the gateway between your home network and the internet. Change the admin password, disable unnecessary services like UPnP, and enable the firewall. That said, the best firewall is of little use if you don’t know what you’re doing. Even more importantly: avoid port forwarding for smart home services. Use a VPN (e.g. WireGuard) or a Cloudflare Tunnel instead. It’s also a good idea to put smart devices on a separate guest network.

➡️ For detailed tips on securing Home Assistant and your home network, see: Securing Home Assistant: 5 Tips for Better Security

➡️ How to set up secure remote access without port forwarding: Avoid Port Forwarding: Secure Remote Access Made Easy

4. Buy Only from Trusted Sources

No-name products from overseas are often cheap, but poorly documented and without ongoing updates. The BSI recommends: buy only from reputable retailers, look for CE marking (though be cautious – it’s not a guarantee!), and pay attention to the manufacturer’s update commitment. Reviews in community forums are often far more revealing than marketing promises.

➡️ Cloud or local? What to look for when buying smart devices: Cloud or Local? Running Smart Devices Securely

5. Use the Cloud Deliberately

The cloud is convenient, but it comes with risks. Manufacturers have to maintain cloud servers – that costs money, and corners are often cut. Only use cloud-dependent features when you truly need them, and isolate cloud-connected devices from the rest of your network (e.g. via a guest network). Many devices also work locally, for example with Home Assistant.

➡️ More on cloud vs. local control and privacy: Cloud or Local? Running Smart Devices Securely

Conclusion

The BSI’s tips are solid, even if they can sometimes feel a bit abstract. You don’t have to implement everything at once – but every step makes your home a little more secure. Watch the video for the full details and practical examples.

Make Your Washing Machine Smart? 5 Things to Know

Sun, 29 Jun 2025 00:00:00 +0200

The first video about the dishwasher got more reactions than expected. Not because of the technology – but because many people had similar problems that I hadn’t even addressed: plugs that melted. Devices that behaved strangely after being switched off. Questions about Aquastop and solar surplus.

The five points here came directly from that feedback.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

1. Watch the Maximum Load

Perhaps the most important point first: many smart plugs are only rated for 10A/2500W. Some appliances – especially older models – can draw 2800 or even 3000 watts during the heating phase. In the worst case, this can cause the plug to overheat or even melt – as happened to one viewer. Measure your device’s power draw beforehand, or check the rating plate. Better to use a plug rated for 16A/3500W, e.g. Shelly Plug (not the S), Sonoff, TP-Link, or AVM.

Suitable smart energy-monitoring plugs (affiliate links):

Fritz!DECT 200 https://amzn.to/44armtk
Shelly Plug S https://amzn.to/4k0PZie – or at OBI: https://www.awin1.com/cread.php?awinmid=9326&awinaffid=2527487&ued=https%3A%2F%2Fwww.obi.de%2Fp%2F7119407%2Fshelly-smart-stecker-plug-s-gen3-weiss – or directly at Shelly: https://upf.ai/l24blt88 (code SMARTHOMEABERSICHER-10OFF for 10% off)
TP-Link Tapo https://amzn.to/4lewLq3
More options: https://amzn.to/4lcpZRE

2. Cutting Power – Is That Even Safe?

A valid concern raised by the community: what about Aquastop and leak protection? In most cases, switching off after the wash cycle is actually safer, because the valve is closed when unpowered. However, some manufacturers have systems that require a constant power supply. When in doubt, check the manual or contact the manufacturer. For most appliances, switching off after the cycle is harmless – and saves standby power.

3. What Does “Smart” Actually Mean?

It’s not just about detecting the “done” status – with solar surplus or a dynamic electricity tariff you can get even more out of it. A basic setup with power monitoring is the foundation for further automations. If you have solar panels or use a dynamic tariff, you can switch the plug on at the right time – a few lines of automation in Home Assistant are all it takes.

4. Door Sensor, TTS, Angry Mode: Next-Level Smart!

A community tip: combining a door sensor with text-to-speech announcements takes things to the next level. Automatic resets, funny phrases, and even increasingly “annoyed” reminders motivate everyone to unload the machine – kids included! One viewer even used ChatGPT to generate a set of messages that get progressively more irritated the longer the wait.

5. Switching On – How Does That Work?

Whether your dishwasher automatically resumes after a power interruption depends on the model – just try it out. Start the appliance, pull the plug, plug it back in – if it keeps running, you’re good to go. If not, you can still use the power monitoring; you just won’t be able to start it automatically via an automation. Personally, I switch the plug on with a long press on the light switch, for example.

Conclusion: With these tips your appliances become truly smart – and you get the most out of your household setup. Watch the video for all the details and practical examples!

5 Automation Mistakes Everyone Makes in Home Assistant

Sun, 22 Jun 2025 00:00:00 +0200

Sound familiar? You built an automation, but it doesn’t work the way you intended? Or you have lots of automations but keep running into problems? Then you’re in the right place! In this article I’ll show you the five most common mistakes when designing Home Assistant automations – and how to avoid them easily.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

1. Automations That Are Too Complex

If you no longer remember what your automation is actually supposed to do after two weeks, it has probably become too complex. Split large automations into several smaller ones – this makes them easier to understand and maintain. For example: control your blinds with multiple automations for different triggers rather than cramming everything into one.

2. Too Many Automations Interfering With Each Other

More isn’t always better! When multiple automations access the same entity, conflicts can arise. Think carefully about when it makes sense to keep automations separate – and when it’s better to combine them to avoid race conditions.

3. Not Tested – or Only Tested in Daily Use

Test your automations deliberately before letting them run in everyday life. Think through which triggers, conditions, and actions you need in advance – and verify that everything works as intended. It saves frustration for you and your family!

4. Unclear Naming

Give your automations and entities clear, unambiguous names. It’s worth keeping a small glossary so you always know what’s meant – and can find automations quickly when you need them.

5. Wrong Automation Mode

Many problems arise because the wrong mode (Single, Restart, Parallel, Queue) was chosen. Learn how the modes work – and pick the right one for your automation. More on this in the video!

Summary: With a few simple tricks, your automations become more reliable and easier to manage. If you want even more tips, check out the video!

5 More Automation Mistakes in Home Assistant – Are You Affected? – The follow-up: new pitfalls around trigger IDs, hardcoded time values, and AI-generated automations
Securing Home Assistant – 5 Mistakes to Avoid in Your Smart Home – Once your automations work, the security mistakes come next: the next level

Home Assistant Automation Modes Explained for Beginners

Sun, 15 Jun 2025 09:00:00 +0200

Home Assistant Automation Modes for Beginners

You built an automation but it sometimes behaves strangely? Or you’re wondering what the different modes like Single, Restart, Parallel, and Queue actually mean? In this article I’ll explain the differences, show you practical examples, and help you find the right mode for your automations.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What Are Automation Modes?

In Home Assistant, you can configure for each automation how it behaves when it is triggered multiple times. This is important so your automations work reliably and as intended.

Single: The automation runs only once. If it is triggered again while still running, nothing happens.
Restart: If the automation is triggered again, the current run is cancelled and it starts over from the beginning.
Parallel: The automation can run multiple times simultaneously.
Queue: New triggers are placed in a queue and processed one after another.

Practical Examples

Take a look at the video for examples like motion-triggered lights, doorbells, or voice announcements. There is a right mode for every use case. You should use Parallel with caution though — find out why in the video.

Conclusion: With the right mode your automations become more reliable and you save yourself a lot of frustration. Watch the video to see all the details and examples!

SSH with YubiKey: Properly Secure Your Smart Home Server

Sun, 08 Jun 2025 09:00:00 +0200

Why Securing SSH in Your Smart Home Matters

Sound familiar? You’re about to leave for vacation and quickly want to change something in your system – only to find that remote access suddenly stops working. Many people then simply open their SSH port to the internet or use the Home Assistant Web Terminal add-on in the browser. That sounds convenient, but it’s extremely dangerous: often a single password is all it takes for someone to gain full access to your entire system.

In this video, I’ll show you how to properly secure your SSH access with a YubiKey. It’s easier than you think – and I’ll walk you through it step by step.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What Is a YubiKey and Why Is It So Secure?

The YubiKey is a small USB stick that works like a digital key for you. It stores your access credentials in a way that they never reside on your computer and can’t be stolen. For SSH, the YubiKey uses the modern security standard FIDO2. Even if someone knows your password, they can’t access your server without the YubiKey. You plug in the stick, tap it – and you’re securely logged in. This is far more secure and convenient than traditional passwords or certificate files stored on your machine.

Where to Buy a YubiKey

You can get a YubiKey through my recommended links:

The following models are suitable for this project:

Tip: Always order from the official retailer or a trusted shop to ensure you receive a genuine, sealed device.

Note: These are affiliate links. If you order through them, you support my blog – at no extra cost to you. Thank you!

Password: Simple, but insecure – passwords can be guessed, intercepted, or shared.
Certificate (key pair): Much more secure, but if someone gains access to your computer, they can copy the private key.
YubiKey: The private key doesn’t live on your computer – it’s securely stored on the YubiKey. Access is only possible with the physical stick and your confirmation.

Step by Step: Setting Up a YubiKey for SSH (Using Termius as an Example)

Choose your YubiKey: There are various models (USB-A, USB-C, NFC, Lightning). Think about which devices you’ll be using the stick with.
Install Termius: This app makes the setup particularly straightforward. (OpenSSH, PuTTY, etc. also work.)
Add the YubiKey: In Termius, go to “Keychain” → “FIDO2”, select the stick, enter your PIN, name and generate the key. Enable “Require user presence”, disable “Require PIN code”, and leave the passphrase empty.
Copy the public key to the server: Termius offers an export function that automatically adds the key to ~/.ssh/authorized_keys. You can also do this manually.
Test the connection: Start a new SSH session, tap the YubiKey – done!
Disable password login: Set PasswordAuthentication no in /etc/ssh/sshd_config and restart the SSH service.

Important Notes & Tips

When setting up your YubiKey for the first time, you’ll need to set a PIN. This protects against misuse if someone finds the stick.
The private key is split into two parts: one stays on the computer, one on the YubiKey. For a new machine, you’ll need to generate a new key pair and register the public key on the server.
“Resident keys” (keys stored directly on the YubiKey) are a special case and aren’t yet widely supported by many tools.
It’s best to set up a second YubiKey as a backup right away, so you don’t lock yourself out.
If everything does go wrong: you can always access your machine directly with a monitor and keyboard.

YubiKey in Everyday Use: Much More Than Just SSH

The YubiKey can do much more: two-factor authentication for Google, Microsoft, Facebook, Dropbox, Amazon, password managers like Bitwarden or 1Password, online banking, email accounts, and much more. Once set up, it becomes a real everyday companion for everything that matters to you.

Conclusion

With a YubiKey, you make your SSH access – and many other logins – not only more secure, but also more convenient. You protect yourself against password theft, phishing, and many other attacks, all with a small stick that fits in any pocket.

GMKtec NucBox G3 Plus as a Smart Home Hub: Review

Sun, 01 Jun 2025 00:00:00 +0000

My father needed a new computer – compact, quiet, affordable. My parents have been running Ubuntu for years, so no big setup drama. The GMKtec NucBox G3 Plus ticked all the boxes, and when the device arrived, I glanced at the specs and thought: Hold on. This would actually make a pretty solid smart home server.

So I just gave it a try. Ubuntu, Home Assistant, a few benchmarks against my Raspberry Pi – and in the end I learned more than I expected.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Why a Mini PC as a Smart Home Hub?

Many people rely on Home Assistant, OpenHAB, or ioBroker – usually on their own hardware running 24/7. The Raspberry Pi is popular, but has its weaknesses: SD card failures, finicky power supply, and limited performance. Intel NUCs are powerful, but often expensive. The NucBox G3 Plus offers an interesting alternative: compact, quiet, expandable, and attractively priced.

The GMKtec NucBox G3 Plus at a Glance

Compact mini PC, barely larger than the palm of your hand
Up to 16 GB RAM, fast NVMe SSD (up to 1 TB)
Intel N150 Quad-Core processor
Quiet fan, barely audible in everyday use
HDMI, 4x USB 3.0, 2.5 Gbit LAN (ideal for NAS/backups)
Easy to open and upgrade (RAM/SSD)
Variants with 8/16 GB RAM and 256/512/1024 GB SSD
Powered via 12V power supply (36W); HDMI cable and mounting rail included

Order directly here:

GMKtec G3 Plus N150 Mini PC Intel Twin Lake N150, 16 GB RAM 3200 MHz, 512 GB PCIE3.0 SSD (affiliate link)
GMKtec G3 Plus N150 Mini PC Intel Twin Lake N150, 16 GB RAM 3200 MHz, 1024 GB PCIE3.0 SSD (affiliate link)
GMKtec G3 Plus N150 Mini PC Intel Twin Lake N150, 8 GB RAM 3200 MHz, 256 GB PCIE3.0 SSD (affiliate link)

Advantages Over Raspberry Pi & Intel NUC

More performance and RAM than a Pi, cheaper than most NUCs
Future-proof thanks to expandability
2.5 Gbit Ethernet for a fast home network
No SD card issues, fast NVMe SSD
Flexible for Home Assistant, Proxmox, Docker, VMs

Comparison: NucBox vs. Raspberry Pi vs. Intel NUC

Device	RAM	Storage	Network	Power draw	Noise	Price
Raspberry Pi 4	up to 8 GB	SD/USB/SSD	1 Gbit	~5 W	passively cooled	varies
Intel NUC (classic)	up to 32 GB	SATA/NVMe	1 Gbit	10–20 W	often audible	expensive
NucBox G3 Plus	up to 16 GB	NVMe	2.5 Gbit	~7 W	very quiet	fair

Hands-On: Setup & Operation

I tested Ubuntu and Home Assistant – both run without issues. For beginners I recommend Ubuntu Server or Home Assistant OS directly on the NucBox. More advanced users can run Proxmox and operate multiple VMs and Docker containers. Before installing, it’s worth checking the BIOS: the “CPU Performance” setting can be switched to “Performance” to get the most out of the CPU – without any noticeable increase in fan noise.

Noise & Power Consumption

Idle draw around 7 watts, briefly up to 15 watts during boot
Annual consumption approximately 61 kWh (~€21.50 at €0.35/kWh)
Fan barely audible in everyday use (approx. 35 dB right next to the device)
Less suitable for bedroom use, no problem in a living room

Conclusion & Recommendation

The GMKtec NucBox G3 Plus is a powerful, quiet, and flexible smart home hub. It delivers more performance and convenience than a Raspberry Pi, costs less than most classic NUCs, and scores points with 2.5 Gbit LAN, a fast SSD, and expandability. Ideal for ambitious smart home setups, Docker, VMs, and fast networks.

Are you running a mini PC as your smart home hub? Or are you still sticking with the Raspberry Pi? Let me know in the comments.

Make Any Dishwasher Smart – No Cloud, No Rewiring

Sun, 25 May 2025 00:00:00 +0000

Your dishwasher isn’t smart yet? Not for long! In this article I’ll show you how to bring any old appliance up to speed with one simple trick – no rewiring, no cloud, just a small smart plug. The same principle works equally well with washing machines, dryers, or any other household appliance that runs a cycle and then gets forgotten.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What you get out of it

Automatic notification when the cycle is done
Saved standby power
Increased safety at home
Ability to switch the appliance off remotely

The idea: energy monitoring instead of cloud

Many new appliances are “smart” – but usually only through manufacturer-dependent clouds. Why buy something new when the existing machine still works perfectly? With a smart plug like the Shelly Plug S (or any other relay with energy monitoring) you can retrofit any appliance and integrate it into Home Assistant – completely local, no cloud required.

The following devices are suitable for this project:

Shelly Plug S (affiliate link) Or at OBI: Shelly Plug S (affiliate link) Or directly at Shelly: Shelly (affiliate link, code SMARTHOMEABERSICHER-10OFF for 10% off)
Shelly Plus 1 PM (affiliate link) Or at OBI: Shelly Plus 1 PM (affiliate link) Or directly at Shelly: Shelly (affiliate link, code SMARTHOMEABERSICHER-10OFF for 10% off)
Sonoff POW R2 (affiliate link)
Sonoff POW Elite (affiliate link)
Smart Plug (affiliate link)

How the detection works

The idea is simple: the power consumption of the appliance is measured. If it exceeds a certain threshold for a certain period of time, the wash cycle is running. If it drops below that threshold – again for a defined period – the appliance has most likely finished. To prevent the automation from reacting to every small spike, a hysteresis is built in, meaning a delay or waiting period.

Determining typical values

Measure a complete cycle of your appliance and observe the power draw. In my case, that’s more than 5 watts for at least 5 minutes (appliance running) and less than 5 watts for at least 5 minutes (appliance done). The exact values can vary depending on the model – experiment and adjust the thresholds accordingly.

Implementation in Home Assistant

I also walk through this step by step in the video – feel free to check it out for the screencast!

Add the device: Integrate the Shelly Plug S or another smart relay with energy monitoring into Home Assistant.
Create sensors: Set up threshold sensors (e.g. using a template or a threshold sensor) that detect the appliance’s status.
Automation: Create an automation that notifies you when the appliance is done – or that cuts power to the device completely after the cycle finishes.

Robust template sensor: handling connection drops

A simple template sensor has one weak spot: if the smart plug briefly loses its connection (Wi-Fi dropout, Home Assistant restart), the power sensor returns unavailable – and the binary sensor snaps to false. That incorrectly triggers a “cycle done” notification even though the machine is still running.

The fix: freeze the last known state for as long as the plug is unreachable. In the video I only showed the basic version – viewer Andreas Schneider sent me a more robust configuration that I’m happy to share here:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


binary_sensor:
 - name: "Dishwasher active"
 unique_id: dishwasher_active
 delay_off:
 minutes: 7
 delay_on:
 minutes: 2
 state: >-
 {% set switch = states('switch.dishwasher_plug') %}
 {% set power = states('sensor.dishwasher_plug_power') %}
 {% if switch == 'off' %}
 {{ false }}
 {% elif power in ['unavailable', 'unknown'] %}
 {{ this.state == 'on' }}
 {% else %}
 {{ power|float > 5 }}
 {% endif %}
 icon: "{{ 'mdi:dishwasher' if this.state == 'on' else 'mdi:dishwasher-off' }}"
 availability: "true"

Adjust the entity IDs (switch.dishwasher_plug, sensor.dishwasher_plug_power) to match your own setup. The threshold (> 5) can be tuned as described above.

Why this configuration is better:

delay_on: 2 min – prevents short startup spikes from activating the sensor too early
delay_off: 7 min – buffers brief pauses mid-cycle (e.g. during heating phases)
The elif block freezes the state on connection loss instead of falling to false
availability: "true" keeps the sensor itself always available, regardless of the plug’s state

Practical example: saving standby power

You can also see this workflow in the video as a screencast – check it out if you want to watch the implementation live!

After the wash cycle, I switch the dishwasher off completely. My appliance draws 4 watts in standby – that’s 35 kWh per year, or roughly €12 at €0.35 per kWh. You still need to subtract the smart relay’s own consumption of about 1 watt, which leaves around €9 in savings per year. That means the Shelly Plug S pays for itself in just over a year. Take a measurement on your own appliance – you might be surprised what a power drain it actually is.

Benefits & safety

No more standby, no voltage at the appliance
Greater safety (e.g. when away from home for longer periods)
Control and monitoring from anywhere

Conclusion

With a simple smart plug and Home Assistant you can make any old appliance smart – no cloud, no rewiring, and no vendor lock-in. You save electricity, improve safety, and always know whether your dishwasher (or any other appliance) has finished its cycle.

→ This video generated a lot of feedback. I’ve compiled the most useful practical tips from the community in a follow-up article: Making your washing machine & dishwasher smart? 5 things you should know!

Robot Vacuums: The Underestimated Smart Home Data Hog

Thu, 15 May 2025 00:00:00 +0000

Introduction

Imagine your robot vacuum knows more about you than your closest friends — even though it’s only supposed to clean the floor. It drives through your home, scans your rooms, listens to your conversations, and you think it’s really just vacuuming? Sounds like a horror movie, but that’s exactly reality.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The Ecovacs Incident of 2024

In October 2024, hacked Ecovacs robot vacuums in the US turned into full-blown stalkers ¹. They chased pets and hurled racist insults at their owners, terrorizing entire households ². But how did it get to this point? The attackers exploited a glaring security vulnerability in the robots’ software. The security PIN that was supposed to prevent unauthorized access was only verified in the app, not on the device itself — a fatal flaw that hackers knew how to exploit ³.

What makes this case particularly alarming: common security measures like strong passwords or two-factor authentication would not have helped here. The manufacturer had made such a fundamental programming error that even best-practice security measures were rendered useless.

The Underestimated Problem of Profiling

But even if your robot vacuum isn’t hacked, there is another massive problem: profiling. Many people might think, what could a robot vacuum really know about me? The answer is: frighteningly much.

To understand how powerful data analysis can be, here is a real-world example from the US: In 2012, a teenager suddenly started receiving ads for baby products from the retail chain Target. Her outraged father complained to Target about the alleged harassment of his daughter — only to find out a few days later that his daughter was actually pregnant. The algorithm had detected subtle changes in purchasing behavior and drawn the right conclusions before the family even knew ⁴.

What Does This Mean for Robot Vacuums?

Your robot vacuum links movement patterns, camera images, and sounds. It knows:

When you sleep
When you come home
Whether your routines change
Which rooms are used and how often
What conversations take place in your home

Why This Matters

“Why would anyone spy on me? I’m not important at all.” This thought is understandable, but it misses the core of the problem. It’s not about targeted surveillance of individuals — it’s about mass data collection:

Companies don’t specifically target your data
They simply collect everything, because storage is cheap
What seems harmless today can become highly sensitive tomorrow through AI analysis
The value lies not in any single household, but in the sheer volume of data

This data can feed algorithms that make decisions about:

Health insurance eligibility
Credit scoring
Personalized advertising

Concrete Recommendations

What can you actually do to protect yourself?

Basic security measures:
- Use strong passwords
- Install updates regularly
- Put devices on a guest network
Consider before buying:
- Think twice before getting devices with cameras or microphones
- Be especially critical of cloud-based data processing
Alternative solutions:
- The Valetudo project offers open-source firmware for some robot vacuum models
- This lets you keep control over your own data

Conclusion

Even large, seemingly trustworthy brands are not immune to data breaches — as the Volkswagen incident of 2024 illustrates, where data from over 400,000 electric vehicles ended up unprotected on the internet ⁵.

Making a genuinely reliable purchase recommendation for a “secure” robot vacuum is nearly impossible. The most pragmatic approach seems to be avoiding models with cameras and microphones and accepting the reduced feature set. An alternative for tech-savvy users is the Valetudo project ⁶, which provides an open-source alternative to the manufacturer’s firmware. Because in the end, protecting your privacy matters more than the supposed convenience of extra features.

Pollen Alert on Your Dashboard: Never Forget Allergy Meds

Mon, 28 Apr 2025 00:00:00 +0000

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Pollen in Home Assistant: Stay Informed at a Glance!

Spring is finally here! For many people, though, that also means pollen season — and with it, the daily challenges for allergy sufferers. I’m one of them: every morning I check the pollen forecast, figure out which medications to take, and plan my day accordingly. But what if we could skip the app entirely and have all that information right on our Home Assistant dashboard?

Good news: the German Weather Service (DWD) provides a pollen forecast that can be integrated into Home Assistant. The raw presentation, however, isn’t very user-friendly. In this article I’ll show you how to process the data into something useful and display it clearly on your dashboard.

Why Put Pollen Levels on the Dashboard?

Especially in the morning, it saves time and gives you peace of mind to see your pollen exposure at a glance — without having to open an app. Even better: with targeted notifications, you’ll be alerted automatically whenever levels exceed a threshold that matters to you.

Setting Up the DWD Pollen Integration

Home Assistant lets you use DWD pollen forecast data via HACS (Home Assistant Community Store). Here’s how to get it running:

Make sure HACS is installed in your Home Assistant. If not, you can find installation instructions here.
In Home Assistant, go to HACS → Integrations.
Search for “DWD Pollenflug” and install the integration.
Restart Home Assistant to activate the integration.
Go to Settings → Integrations and add the DWD Pollenflug integration. Select your desired location.

Once set up, you’ll have sensors available for various pollen types.

You can find more about the integration at https://github.com/mampfes/hacs_dwd_pollenflug

Processing the Data to Make It Useful

The raw data delivered by the integration can be hard to interpret since it only contains numerical values. I recommend creating template sensors that translate the exposure into easy-to-understand categories like “low”, “moderate”, or “high”.

Here’s an example of what such a template sensor might look like:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


sensor:
 - platform: template
 sensors:
 birke_pollen_level:
 friendly_name: "Pollen Level Birch"
 value_template: >-
 {% if states('sensor.dwd_pollen_birke') | int == 0 %} No exposure
 {% elif states('sensor.dwd_pollen_birke') | int == 1 %} Low exposure
 {% elif states('sensor.dwd_pollen_birke') | int == 2 %} Moderate exposure
 {% else %} High exposure
 {% endif %}

This lets you see at a glance how heavy the pollen load is for specific plants.

Even Better: A Personalised Pollen Profile

It’s worth aggregating pollen levels into a single personalised tile. Depending on the severity and the pollen types you react to, you can create a generic problem entity. With appropriate visibility conditions added to your dashboard configuration using “or” logic, you can build a personalised pollen warning that gives you a tailored overview matched exactly to your needs. I walk through this in detail in the video.

What’s Next: Automations

If you’re looking for more ideas on how to make your smart home allergy-season ready, I recommend checking out the article „Home Assistant gegen Pollen: Drei Automatisierungen für Allergiker" on heise online. You’ll find practical examples of how to set up push reminders, light-based warnings, and smart air purifier control with Home Assistant — great for keeping pollen levels manageable day to day.

Conclusion: A Relaxed Pollen Season

With the DWD pollen forecast integration and a bit of personalisation, you can turn your Home Assistant dashboard into a genuine allergy companion. No more morning surprises — just a clear picture of what’s ahead.

4 Dashboard Tricks So You Never Miss Anything

Thu, 24 Apr 2025 00:00:00 +0000

Whether warning symbols, color highlights, or dynamic display: these four ideas take your dashboard to the next level – functional, elegant, and practical for everyday use.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

In everyday life it can easily happen that important information gets lost in the smart home dashboard – be it humidity that’s too low, a door left open, or a device that has gone offline. In this post I’ll show you four concrete methods to make sure such information is visually highlighted and no longer overlooked in Home Assistant.

Why Visual Highlighting Matters

Home Assistant offers many automation options, but a lot of potential is wasted when it comes to dashboard presentation. A uniformly grey dashboard lets important alerts fade into the background – with targeted use of colors and symbols you can change that.

Method 1: Colored Backgrounds with CardMod (Static)

With card-mod you can customize the background color of individual cards. This works even without conditions – for example to highlight specific sensors.

Example:

1
2
3
4
5
6


card_mod:
 style: |
 ha-card.active {
 background-color: #ffcccc;
 --state-icon-color: red;
 }

Method 2: Dynamic Colors via Template and CardMod

A bit more advanced, but very effective: you use a template to automatically choose a color based on the sensor value – for example for humidity or temperature.

Example:

1
2
3
4
5
6
7
8
9


card_mod:
 style: |
 ha-card.active {
 background-color: {{
 '#ffcccc' if (states('sensor.graserpollen') | int > 2)
 else '#ffffcc' if (states('sensor.graserpollen') | int > 1)
 else '#ffffff'
 }};;
 }

Method 3: Warning Symbols via “unavailable” Status (Helper Sensor)

A clever trick: Home Assistant displays a yellow warning symbol (⚠️) when a sensor’s status is unavailable. You can use this deliberately – for example with an additional template sensor that only takes on this status under certain conditions.

Example:

1
2


# Template sensor with unavailable status for visual highlighting
{{"unavailable"}}

Method 4: Display via binary_sensor with device_class “problem”

If you want a striking red warning symbol, you can use a binary_sensor with device_class: problem. As soon as the state switches to on, Home Assistant automatically shows the symbol.

Example:

1
2


# Template for binary_sensor with problem indicator
{{true}}

Conclusion

These four methods help you make your dashboard not only nicer, but also more functional and more reliable. In everyday life it’s crucial to see at a glance when something is wrong – and that’s exactly what visual cues like colors, symbols, and status indicators help you with.

Tip: Combine multiple methods – for example a tile with a colored background and a symbol – so you’re guaranteed never to miss anything.

→ I covered the basics of conditional display with card-mod in the first part of this series: Fehler und Warnungen im Home Assistant Dashboard richtig anzeigen

Remote Access with Cloudflare – Done Right!

Fri, 18 Apr 2025 00:00:00 +0000

Many people set up a Cloudflare Tunnel, see that Home Assistant is reachable from anywhere — and stop right there. The problem: the tunnel is encrypted, but anyone can access it. No login, no access control, nothing. It’s like locking your apartment door while the building’s front door is wide open.

I’ll show you how to do this properly: set up the tunnel, secure access — and at the end, make an honest assessment of what you’re trusting Cloudflare with.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The False Sense of Security Through HTTPS

Many people think: “If I use HTTPS, I’m safe.” But that’s a misconception. SSL encrypts the connection — it does not prevent your Home Assistant from being visible and vulnerable on the internet. That’s exactly what happens when you only set up a tunnel and do nothing else.

Today we go one crucial step further: Cloudflare Tunnel plus access control. If you’ve already set up the tunnel, you can skip ahead to the next section.

Info: The hands-on step-by-step walkthrough is in the video above. You’ll need your own domain to follow along. If you don’t have one yet, I recommend Netcup based in Karlsruhe:

The Weak Spot in Many Cloudflare Setups

Your smart home is now reachable from the internet — and many people stop there, satisfied. But there is one critical problem with this setup: while the tunnel connection is encrypted, anyone can access it.

It’s like locking your apartment door while the front door of the building stands wide open. Today we do better and add an additional layer of protection.

Info: The hands-on step-by-step walkthrough is in the video above.

How Trustworthy Is Cloudflare?

So now, to stay with the analogy, the front door is also securely locked and only someone with keys to both doors can get through. Right? Unfortunately, no. Because there’s one player you may not have on your radar — and that’s Cloudflare itself.

We’ve set up two layers of protection: the authentication in Home Assistant and Cloudflare Access. For a hacker to access your smart home now, they’d need to successfully bypass both security mechanisms — Cloudflare’s and Home Assistant’s. The odds of that are orders of magnitude lower than if the system were just sitting open on the internet. Sounds like a perfect setup? Almost — because there’s one small but important catch.

Cloudflare itself has unencrypted access to everything passing through the connection in this setup. And Cloudflare is a US company, which means it is not subject to the strict data protection regulations that apply here in Europe. You therefore have to place a certain degree of trust in the company behind Cloudflare. If that makes you uncomfortable — what are the alternatives? You could set up your own VPN access with WireGuard or Tailscale — technically a bit more demanding, but privacy-friendly. Or you use Home Assistant Cloud — it’s a paid service, but offers a straightforward and secure solution with considerably more concrete privacy rules than Cloudflare. However, you still have to extend some trust here too, because Nabu Casa — the company behind Home Assistant Cloud — is also a US company and is not bound by EU rules. That said, they do advertise that they don’t log user activity or analyze it for advertising purposes. That may matter to some of you.

My Take

If you use Cloudflare correctly — with Tunnel and Access — you have a free, highly secure solution for remote access to Home Assistant, without opening a single port.

Cloudflare is, however, a US company with unencrypted access to your connection. If that’s not acceptable to you, consider WireGuard, Tailscale, or Home Assistant Cloud instead. More on those coming soon here on “Smart Home? But Secure!”

Why Port Forwarding into Your Smart Home Is So Dangerous

Thu, 10 Apr 2025 00:00:00 +0000

I’ve been diving deep into the topic of remote access to smart home systems lately – and one thing quickly becomes clear: there are now quite a few interesting options available, depending on your security needs, budget, and technical expertise.

Which makes it all the more alarming that many users still simply rely on port forwarding to make their home network services accessible from the internet. Why is that dangerous? Let’s take a closer look.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Hi and welcome! My name is Joachim and this is Smart Home? But Secure! I originally just wanted to put together a video showing you how I’ve been handling secure remote access to Home Assistant for years. But in my research, I realized: there are now quite a few ways to solve the remote access problem elegantly and securely. Yet there are still a large number of users who rely on simple port forwarding (more technically known as port forwarding) to access their smart home systems while on the go. And honestly, that surprised me a bit.

If you’re thinking: “Sure, old news – you don’t need to explain that to me!” – then I’d invite you to subscribe to the channel. I have a feeling this topic has potential for more than one video, and there will definitely be a few more technical deep-dives to come. But if you’re thinking: “Huh? What’s actually the problem with port forwarding?” – then let’s take a closer look right now.

Why Port Forwarding Is So Popular

First of all: it’s understandable why so many users go this route. It’s simple, quick to set up, and generally involves no additional costs. And even the problem of a dynamic IP address can be solved quickly using a dynamic DNS service. But: You have to be aware of what you’re doing: you’re putting your service – for example Home Assistant or OpenHAB – directly onto the internet, exposed exactly the same way it is on your local network.

First Risk: The Protection Layer of Your Home Network Disappears

Even if you’ve set a strong password for your service: your home network itself is an additional layer of protection. In general, far fewer malicious actors are lurking there than on the open internet. With port forwarding, you remove exactly that protective layer. Your service is now directly reachable from the internet – for millions of users, hackers, and other bad actors. And even if you use a secure password and 2FA – nobody can guarantee that a new security vulnerability doesn’t already exist that bypasses authentication entirely. Sure, you can install updates diligently, but those only protect against known and already-patched vulnerabilities. That’s why you should replace that second protective layer – your home network – with something else whenever you want to expose your services on the internet.

Second Risk: Unencrypted Connections

There’s another factor to consider. As soon as your data travels over the internet, it must be encrypted – otherwise anyone can read or manipulate it. Take Home Assistant as an example: the default connection is not encrypted. If you simply open a port to the internet, access is unsecured – just like at home, where that’s usually less of a concern. Of course, you can secure it – for example with a free Let’s Encrypt certificate. But that means additional software and configuration. The “simple” port forwarding quickly turns into a complex software project – and that makes it not only more error-prone but often more insecure as well. A vicious cycle.

My Recommendation

My clear recommendation: don’t use port forwarding to make your smart home accessible from the internet. Even if you don’t have particularly high security requirements, there are better alternatives:

VPN

VPN: If you have a FRITZ!Box or another router that supports it, a VPN can be a great choice. It’s free, significantly more secure, and usually easy to set up. The VPN authentication provides the second protective layer that I believe is so important for internet access.

Home Assistant Cloud

Home Assistant Cloud: The service from the HA team at Nabu Casa is easy to set up and takes care of encryption for you. You don’t have to deal with dynamic DNS either. But: it costs a monthly subscription fee – though at least that money goes to the company developing Home Assistant. The downside is that the second protective layer is still missing – the login screen is directly reachable from the internet, which you’ll quickly notice from “login failed” messages in your Home Assistant log.

Cloudflare

Reverse proxies such as Cloudflare: here you build an encrypted tunnel from your home network to the proxy. There are already many great videos about this from the big smart home channels on YouTube, but I strongly recommend enabling an additional authentication layer on the proxy (called “Access” in Cloudflare) – that gives you your second protective layer here as well. Cloudflare is a US-based provider, which may be a dealbreaker for those with privacy concerns. In my research I haven’t found a comparable European alternative – if you know of one, let me know in the comments!

Twingate

Twingate is a provider that enables zero-trust networking and promises a modern VPN alternative. Setup is surprisingly straightforward, clients are available for all platforms, and access to individual services can be controlled in a very granular way. Even though the service is primarily aimed at businesses, it can be interesting in a smart home context – especially if you want to secure multiple devices or users.

Tailscale

Tailscale takes a different approach: using WireGuard, it builds a private mesh network in which all your devices can reach each other directly – wherever they are. Particularly interesting is the newer Tailscale Funnel feature: it lets you expose a home network service publicly over the internet, including HTTPS and access control. Funnel isn’t available everywhere yet, but it’s a promising approach – especially for technically minded users.

I haven’t taken a closer look at either of these two options (Twingate and Tailscale) myself yet.

What role does remote access play in your smart home setup? Which solution are you using – or which one are you considering? Leave a comment below.

What I Use Personally

I’ve set up my own reverse proxy with the German hosting provider netcup. From my home network I establish an SSH tunnel that exposes only selected services toward the reverse proxy. The proxy itself is responsible for authentication and controls who can access what. I’ve configured it so that a client certificate is required for authentication. That’s how I’ve implemented my second protective layer – without opening any ports. At the same time it’s incredibly convenient, because authentication happens in the background and I don’t need to connect to a VPN or enter additional passwords. It’s certainly not the right solution for everyone – but for technically experienced users, it’s in my opinion a very elegant approach for the level of protection it provides.

What’s Next

In the upcoming videos we’ll take a detailed look at each of these alternatives – so you can find the right solution for your situation.

Backing Up Home Assistant to Google Drive

Thu, 03 Apr 2025 00:00:00 +0000

My first backup video used Microsoft OneDrive as the example. After that, many comments came in with the same question: And how does that work with Google Drive? Fair enough – not everyone wants to use Microsoft. So here’s the answer.

The good news upfront: Home Assistant encrypts its backups by default before they reach the cloud. That means neither Google nor Microsoft can read the contents. This makes storing backups on a third-party service perfectly acceptable from a privacy standpoint – and takes the wind out of one of the most common objections.

The setup with Google Drive is more complex than with OneDrive, however, because you need to complete a few steps in the Google Cloud Console. I’ll walk you through all of them.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Home Assistant Backups with Google Drive

In my previous video on backups, I introduced the new backup mechanism in Home Assistant starting with version 2025.1 and demonstrated – using Microsoft OneDrive as an example – how easy it is to store encrypted backups at a secure second location using the built-in options. The Microsoft OneDrive integration in Home Assistant is very straightforward, but not everyone wants to use OneDrive.

So in this video, I want to show another popular alternative: integrating Google Drive into Home Assistant, step by step. The initial setup is more complex than with OneDrive, so I’ll walk through the entire process.

By the way: since Home Assistant encrypts its backups by default, storing such sensitive backups on cloud storage from Microsoft or Google is not a privacy concern at all, and can in my assessment be done without hesitation.

If you’d like to familiarize yourself with the basics of the new backup mechanism first, I recommend watching this video before continuing. In the following, I’ll focus exclusively on integrating Google Drive into the backup mechanism and won’t repeat the general overview of Home Assistant’s backup system here.

Prerequisites

You’ll need a Google account to get started. Your Home Assistant installation also needs to be running a version that supports the new backup mechanism, i.e., version 2025 or later.

What you need to set up in Google and why:

For Home Assistant to communicate with Google Drive, you need to create the following elements in the Google Cloud Console:

Google Cloud Project
The project is the container where all configuration for your Home Assistant connection is collected. You can manage specific settings and all access centrally here.
OAuth Consent Screen
This step is required to identify Home Assistant as an application authorized to communicate with your Google Drive. Here you define basic information about the application, such as name, email address, and access permissions.
OAuth Client (Web Application)
The OAuth client is the access key that Home Assistant uses to authenticate with your Google account. It consists of two parts: the Client ID and the Client Secret. These are entered into Home Assistant later.
Google Drive API
This API allows Home Assistant to access your Google Drive and store or retrieve files there. It must be explicitly enabled for the connection to work.
Test Users
Since your application is not verified by Google, you need to add your own email address as a test user to gain access.

Integrating Google Drive into Home Assistant

In your Home Assistant installation, go to Settings and then Integrations. Click Add Integration and search for the entry Google → Google Drive.

The setup wizard that follows will ask you for a name (which you can choose freely), as well as an OAuth Client ID and an OAuth Client Secret.

In the upper section of the setup wizard, the necessary links are provided for creating this ID and secret. Let’s take a closer look at those now.

Click the OAuth Consent Screen link and sign in with your Google account if you haven’t already. You’re now in the configuration area of the Google Cloud, in the Google Authentication Platform dialog.

Creating a Google Project

If you’ve never been here before, you need to create a project first.

Click Create Project and give your project a name, for example Home Assistant Backup.
Click Create and wait a few seconds for the project to be created.

Registering an OAuth Application with Google

Creating the OAuth Configuration

You’ll now see the OAuth Overview screen with a notice that the Authentication Platform has not yet been configured.

Click Get started.
Enter a name for the app, for example Home Assistant or Home Assistant Backup.
Under User support email, select your email address from the dropdown menu and click Next.
Under Audience, select the option External and click Next.
Under Contact Information, enter your Google email address and click Next again.
Confirm the User Data Policy with a click and select Continue.
Click Create.

Google will now confirm with the message OAuth Configuration Created that everything was set up successfully.

Creating an OAuth Client

On the screen shown, click Create OAuth Client.
Under Application Type, select Web Application.
Leave the name as Web Client 1 or enter a custom name like Home Assistant Backup.
Scroll down and under Authorized Redirect URIs, click the Add URI button.
Paste the address that Home Assistant shows you in the setup dialog under Step 5.
Click Create.

Google will now display the generated Client ID and Client Secret. Copy this information and paste it into the Home Assistant setup dialog.

Configuring Audience and Test Users

To actively use the authentication, you still need to add your email address as a test user on the Google side.

In the Google Cloud Console, navigate from Clients to Audience in the left sidebar.
Scroll down to Test Users.
Click Add Users and enter your Google email address.
Confirm your entry.

Enabling the Google Drive API

Before everything works, you need to enable the Google Drive API in the Google Cloud Console so that Home Assistant can use it after authentication.

In the Google Cloud Console, switch from Google Authentication Platform to APIs & Services in the left navigation bar.
Click Enable APIs and Services.
Type Drive into the search field.
Select Google Drive API from the search results.
Click Enable.

This may take a few seconds. Afterwards, you’ll be redirected to a screen showing details about the Google Drive API usage.

Completing the Connection with Home Assistant

Return to Home Assistant and click Open Website.
Select your Google account again if prompted.
Confirm Google’s warning that this application has not been verified by clicking Continue.
On the next screen, confirm that you want to link your Google account with Home Assistant and click Continue.

At this point, a wizard to open My Home Assistant Links may appear.

Enter your Home Assistant URL once and confirm with Save.
Finally, the prompt Link Account Home Assistant will appear, which you can confirm by clicking Link Account.

Completing the Setup in Home Assistant

Return to Home Assistant, where you’ve already entered the API Key, OAuth Key, and Client Secret.
Click Open Website.
Select your Google account and confirm that the app has not been verified by clicking Continue.
Confirm once more that you want to proceed with the configuration.
Finally, click Link Account.

If everything has been set up correctly, you’ll receive a Success message in Home Assistant confirming that the Google Drive configuration has been created.

Configuring Backup Settings in Home Assistant

You can now – as you may already know from the previous video – go to Settings > System > Backups, then Backup Settings > Backup Locations and enable Google Drive there.

From now on, your backups will be saved not only locally, but also to Google Drive.

→ If you want to understand why it’s important not to rely solely on manufacturer clouds, this article is worth a read: Wenn dein Smart Home plötzlich dumm wird – und was du dagegen tun kannst

Never Forget to Put the Bins Out Again with Home Assistant

Tue, 01 Apr 2025 00:00:00 +0000

Do you keep forgetting to put your bins out in time? With two Home Assistant integrations — Waste Collection Schedule and Card-Mod — you’ll get a prominent alert sent straight to your smartphone and displayed on your dashboard. Once the job is done, you can confirm the alert so it disappears from the dashboard. I’ll show you how to get this working in three simple steps.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

The whole setup comes down to three simple steps:

Install HACS and the integrations: We install HACS and set up the required integrations.
Configure Waste Collection Schedule: I’ll show you how to automatically capture your bin collection dates.
Set up the dashboard alert: You’ll learn how to add a prominent warning to your dashboard and make it disappear once the bins are out.

At the end, I’ll share a bonus tip — a small hidden feature of the integration. Let’s get started!

Installing Everything

HACS

I’ll quickly walk through installing HACS in case you haven’t done it yet. If you’re already familiar with it, feel free to skip to the next section — it only takes a moment, because HACS is really quick to set up.

If you haven’t installed HACS yet, you’ll find all the details at hacs.xyz. If you want to get it done fast, just run this command on your system:

1

wget -O - https://get.hacs.xyz | bash -

Afterwards, restart Home Assistant and you can set up HACS via “Add Integration”. This requires authentication via GitHub. You’ll be guided through the process almost automatically. Once everything is done, you’ll see a new HACS entry in the Home Assistant sidebar on the right.

Waste Collection Schedule & Card-Mod

Now we need two integrations, both available through HACS:

Waste Collection Schedule (for parsing bin collection dates)
Card-Mod (for a visually prominent display on your dashboard)

Steps:

In Home Assistant, go to HACS in the sidebar.
Search for “card-mod” and “waste collection”.
Download both integrations by clicking the menu on the right and confirming “Download” twice.
A restart of Home Assistant may be required after installation.

Setting Up Waste Collection Schedule (WCS)

Waste Collection Schedule (WCS) supports a wide range of providers. If your provider isn’t listed but offers calendar files in ICAL format, you can easily add them via “Generic”.

In a spot check of various districts in Germany, I didn’t find a single one that wasn’t already in the list.

Setting up your provider in WCS:

Go to: Settings > Integrations > Add Integration and select “Waste Collection Schedule”.
Select your country, e.g. Germany.
Search for your source: Look up your city or district.

Adding the URL:

Copy the URL from your waste management provider’s website.
Paste it into the setup dialog under “URL”.

Creating Sensors

Give each sensor a descriptive name, for example “Green Bin”.
In the “Value Template Preset” field, select “Numeric Days To”.
At the bottom under “Types”: Choose the correct label, e.g. “Organic Waste”.

Automations & Dashboard

There are several ways to use this information through automations or dashboard visualizations. I’ll show you two options:

Option 1: Notification via Automation

Go to: Settings > Automations and create a new automation.
Give it a name, for example “Bin Reminders”.
Set the trigger: Click “Add Trigger” > “Time & Location” > “Time” > “Fixed Time”.
- Choose a time when you’d like to be notified, e.g. late afternoon the day before collection.
Define conditions: Add a “Choose” block to distinguish between different bin types.
- For example: if the state of the green bin sensor is “1” (meaning collection is scheduled for the next day), you want to be notified the afternoon before.
Set actions:
- Choose “Send Notification” and enter a message, e.g. “Put the green bin out”.
Add a separate option for each additional bin type and define the corresponding conditions and actions.

This automation ensures you reliably receive reminders whenever it’s time to put your bins out.

Option 2: Display on the Home Assistant Dashboard

I know the problem all too well: you get a notification, you register it, and then forget about it anyway. In the worst case, you accidentally swipe it away.

That’s why I’ve found it far more effective to display the reminder on the Home Assistant dashboard — in a way that only disappears once you actively confirm it.

You can easily extend the automation you just created to handle this.

Preparation: Create a Helper

Go to: Settings > Devices & Services > “Helpers” tab.
Create a new helper: Select “Toggle”.
Name the toggle something like “Put green bin out”.
This toggle will be used to display and manage the bin collection status on your dashboard.

Extending the Automation

Go back to the automation you created and open the configuration for “Option 1”.
Add an additional action:
- Alongside the notification, add another action:
- “Input Helper” > “Turn on” > select your helper “Put green bin out”.

Setting Up the Dashboard Display

Add a tile to your dashboard that displays the “Put green bin out” helper.
Configure visibility:
- Set a condition so that this tile is only shown when the helper is turned on.

Your automation will now activate the helper the day before collection and display it on your dashboard. Once you’ve put the bin out, you tap the tile, which sets the toggle back to “Off” — and the tile disappears.

The whole cycle repeats in one or two weeks, and you’re guaranteed never to forget to put your bins out on time again. Unless you’re on holiday and can’t see the dashboard from there.

Fun Fact

Thanks to the Waste Collection Schedule integration, you can also display your collection dates in Home Assistant’s calendar view. So if you ever want to see your entire bin collection schedule at a glance, that’s easily possible.

And that’s it! Your Home Assistant will now reliably remind you to put the bins out on time.

Home Assistant Backups 2025.1: Restore Your Data Safely

Sun, 02 Mar 2025 00:00:00 +0000

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Why Are Backups Important?

Imagine your Home Assistant system stops responding. Your automations, devices, and integrations are gone — everything you set up over months or even years, lost. That thought alone is unsettling, isn’t it? But that’s exactly what can happen if you don’t make regular backups.

Fortunately, Home Assistant version 2025.1 introduces an improved backup system that is simpler, more secure, and more powerful than ever before. In this article, I’ll explain why backups are essential, how to set them up in Home Assistant, and which strategies you can use to best protect your data.

What’s New in Home Assistant 2025.1?

The new backup feature makes it even easier to secure your installation. Here are the key improvements:

Automated backups can be scheduled directly within the system.
Cloud storage without extra add-ons — now directly to Google Drive, Microsoft OneDrive, or a Synology NAS.
Encryption by default protects your backups from unauthorized access.
Easy restoration — regardless of which installation method you use for Home Assistant.

This eliminates the need for external scripts or community add-ons to create regular backups.

Comparison: Old vs. New Backup Method

Previous Method

In the past, the backup functionality in Home Assistant was fairly rudimentary. You had to trigger backups manually through the interface or rely on add-ons like Google Drive Backup to store backups automatically in the cloud. A simple, integrated solution for regular, secured backups simply didn’t exist.

New Method in 2025.1

With the new backup feature, you can:

Run backups automatically on a schedule
Store backups directly in the cloud, without third-party add-ons
Selectively back up or exclude specific components
Perform an easy restoration with just a few clicks

In short: it has never been this easy to secure your Home Assistant system!

Step by Step: How to Create a Backup

Watch the video above for a detailed walkthrough of the process.

Tip: Occasionally test the restoration on a separate system to make sure your backups actually work.

Backup Storage Locations – What’s the Best Option?

Home Assistant 2025.1 offers various options for storing your backups:

Local (SD card or SSD) → Quickly accessible, but vulnerable to hardware failures.
Cloud (Google Drive, OneDrive, Synology NAS) → Safe from hardware issues, but dependent on internet access.
Hybrid solution (local + cloud) → The best strategy for maximum security!

Recommendation: Keep at least 7–10 backups to have multiple restore points available.

Best Practices for Your Backup Strategy

To make sure you’re always on the safe side, keep these tips in mind:

✔ Schedule regular backups: Daily or weekly, depending on your usage. ✔ Use encryption: Especially when storing backups in the cloud. ✔ Diversify backup storage locations: Local + cloud for maximum security. ✔ Store important passwords securely: Especially for encrypted backups.

Conclusion: Backups Are a Must for Your Smart Home!

With Home Assistant 2025.1, there are no more excuses to skip backups. The new features make securing your system enormously easy and turn restoration into a breeze when things go wrong.

Try out the new backup feature and make sure your smart home stays protected at all times!

Backing Up Home Assistant to Google Drive – Step-by-step guide to the Google Drive integration, including OAuth setup
Cloud vs. Local – What You Need to Know About Storing Your Data – Why local backups alone aren’t enough and when cloud storage makes sense

Cloud Integrations vs. Local Integrations

Fri, 03 Jan 2025 00:00:00 +0000

Bose simply pulled the plug. Overnight, SoundTouch speakers that cost well over €1,000 turned into expensive paperweights – because the manufacturer shut down its cloud service. Vorwerk did the same thing with Neato robot vacuums. The list keeps growing.

This is the fundamental problem with cloud integrations in a smart home: you buy a device, but you don’t really own the functionality behind it. That belongs to the manufacturer – and they can take it back at any time. Here I’ll look at what that means in practice, and when cloud integrations still make sense.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What are cloud and local integrations?

Cloud integrations connect your devices to external servers over the internet. This lets you access them from anywhere in the world. Examples include Google Nest, Amazon Alexa, and Ring cameras. The cloud offers convenience, but it also comes with risks.

Local integrations, by contrast, run directly in your home network – with no internet connection required. Typical examples are Zigbee devices or ESPHome sensors controlled via a local hub. Local integrations give you more control and independence.

Risks of cloud integrations

Privacy and data security

Many cloud devices send sensitive data to manufacturer servers. A prominent example is the VW data leak in 2024, where a vulnerability exposed the data of 800,000 customers. Security gaps like this can give unauthorized third parties access to your private data.

Vendor dependency

Another risk is dependence on the manufacturer’s services. A well-known example is the Revolv Smart Home Hub, whose servers were shut down by Google in 2016. Users were suddenly left with useless hardware.

Attack surface for hackers

Insecure cloud connections can serve as an entry point into your home network. Once an attacker gains access to a cloud-connected device, they could potentially compromise other devices on your network.

Dependence on internet connectivity

Cloud devices rely on a stable internet connection. If a server goes down or your internet is disrupted, they often stop working entirely. This can cause serious problems with security-critical applications like smart door locks.

Advantages of local integrations

Full data control

With local integrations, all data stays within your home network. You’re not relying on a third party’s data security practices and you minimize the risk of data leaks.

Independence from external services

Local integrations work even without an internet connection. A Zigbee light switch, for example, keeps working even if your internet goes down.

Smaller attack surface

Because there’s no connection to the internet, there are fewer ways for attackers to compromise your network.

Fast response times

Local systems react instantly, since no data has to travel over the internet. This is a decisive advantage for automations and scenarios that depend on precise timing.

How to make cloud integrations more secure

If you want or need to use cloud integrations, there are steps you can take to minimize the risk:

Two-factor authentication (2FA): Enable 2FA to make unauthorized access to your accounts harder.
Strong passwords: Use complex, unique passwords for every service.
Regular updates: Keep all devices and apps up to date to close security vulnerabilities.
Use a separate network: Place cloud devices on a guest network to protect your main network.

When should you choose cloud or local?

Cloud integrations are a good fit if you want to access your devices from anywhere or need complex additional features that depend on external services.

Local integrations are the better choice if you prioritize privacy, security, and reliability.

Conclusion

The choice between cloud and local integrations depends heavily on your individual needs. Both approaches have their pros and cons, but with the right security measures you can minimize the risks. My recommendation: use local integrations wherever possible, and secure your cloud devices carefully. That makes your smart home not just smarter – but also more secure.

When your smart home suddenly turns dumb – and what you can do about it – Concrete examples of manufacturers shutting down their cloud: Bose SoundTouch, Neato, and more.
Home Assistant Backups in 2025 – Your data safe and recoverable at any time – If you rely on local control, you should also back up your data locally.

Smart Electricity Tariff for Your Smart Home: Worth It?

Wed, 25 Dec 2024 00:00:00 +0000

€180 less per year for charging the EV – that’s not a promise from a provider, but a concrete real-world calculation: anyone who charges their car at home and has the right tariff simply pays less, because electricity is significantly cheaper at night or when there’s plenty of wind and solar energy on the grid.

That’s exactly what dynamic electricity tariffs make possible. Whether it makes sense for you depends on one key factor.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What Is a Dynamic Electricity Tariff?

Dynamic electricity tariffs are based on fluctuating prices that follow supply and demand on the electricity market. Unlike traditional fixed-price tariffs or time-of-use tariffs with fixed peak and off-peak windows, prices under a dynamic tariff can change every hour or even every quarter-hour.

For such a tariff to work, you need either a smart meter or an additional device that records your electricity consumption in real time. Only then can your provider match your actual usage data to the dynamic prices.

Pros and Cons of Different Electricity Tariffs

Tariff type	Price changes	Price guarantee	Savings potential
Fixed tariff	None	Fixed	Low
Time-of-use tariff	Fixed time windows	Partial	Medium
Dynamic tariff	Hourly / every 15 minutes	None	High

A dynamic tariff is most worthwhile if you own high-consumption devices such as washing machines, tumble dryers, dishwashers, or electric vehicles that you can run flexibly.

Calculation Examples: How Much Can You Save?

1. Washing Machine and Tumble Dryer

Assumptions:
- 2 laundry days per week.
- Energy use: 1 kWh (washing machine) + 2 kWh (dryer).
- Fixed tariff: 30 cents/kWh.
- Dynamic tariff: Average 25 cents/kWh.
Calculation:
- Saving per laundry day: 3 kWh × 5 cents = 15 cents.
- Saving per year: 15 cents × 104 laundry days = €15.60.

2. Electric Vehicle

Assumptions:
- Annual mileage: 20,000 km.
- Energy use: 20 kWh/100 km.
- 90 % of charging done at home (3,600 kWh).
- Saving: 5 cents/kWh.
Calculation:
- 3,600 kWh × 5 cents = €180 savings per year.

Smart Home Automation

With a smart home you can optimise your consumption without constantly having to check for cheap electricity windows. For example, you can set your EV to automatically charge during the cheapest hours while still being ready to drive in the morning.

My Experience With Tibber

One provider offering dynamic electricity tariffs is Tibber. With a monthly base fee of only €3.99 and transparent pricing, Tibber was an excellent choice for me for a while. Particularly handy: the Tibber app shows you hourly electricity prices in advance and makes it easy to reach customer support.

Note: I’m no longer a Tibber customer these days, but the principle works with any provider that offers dynamic tariffs.

Just Want to Keep an Eye on Your Consumption?

Don’t want a dynamic tariff (yet), just want to see where your electricity goes? That’s much simpler and cheaper: the OBI Energy Tracker* attaches to your electricity meter and shows your consumption in the heyOBI app – no tariff switch and no expensive smart-meter retrofit.

Conclusion

A dynamic electricity tariff can help you save on energy costs, especially if you own high-consumption devices like an EV. With the right automation, using it becomes simple and efficient.

Securing Home Assistant: 5 Mistakes You Must Avoid

Fri, 13 Dec 2024 00:00:00 +0000

In the Home Assistant forum, someone opened their port 8123 in January 2025 – and described how login attacks started within minutes. Massive, automated, relentless. This is not an isolated case. Using services like Shodan, attackers can find open Home Assistant instances in seconds.

Most of these attacks are preventable. Not through complicated measures, but through five things that many people simply never set up.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Home Assistant was built with privacy and IT security in mind, letting you run your smart home completely locally and independently of manufacturers. The local approach minimizes the risk of data leaks. With options like SSL, user management, and regular updates, you can make Home Assistant one of the most secure vendor-independent solutions available – if you use the security features correctly.

Many users overlook important security features or don’t take full advantage of what Home Assistant offers. The problem: this creates unnecessary attack surfaces, so-called attack vectors, through which hackers could break into your smart home. Whether it’s weak passwords, unsecured connections, or outdated software – it’s often small oversights that can have major consequences.

In this article, I’ll show you 5 typical security mistakes and how to avoid them. I’ll give you tips to make Home Assistant even more secure. Whether you’re just setting up your smart home or have been using it for a while – these tips will help you identify potential vulnerabilities and better protect your home.

Mistake 1: Using Weak Passwords or Default Passwords

A classic that is still underestimated: weak or even pre-set default passwords. Many smart home devices connected to Home Assistant come with simple default passwords like ‘admin’ or ‘1234’. And the problem is: these passwords are not only easy to remember, they’re also easy to hack. Attackers use automated programs that try exactly these default passwords in seconds.

Why is this dangerous? A weak password can allow attackers not only to gain access to your smart home, but through Home Assistant to all your devices and automations. Imagine someone being able to control your lights, access cameras, or even disable alarm systems – that would be an absolute nightmare.

The solution is fortunately simple: change default passwords immediately after setting up your device. Use a strong password with at least 12 characters – length is more important than complexity here. Lowercase letters and digits are often perfectly sufficient, as long as the length is right.

Even better is using a password manager like KeePass. It not only generates secure passwords but also stores them securely, so you only need to remember one master password.

My tip: Give every user and every service in your smart home its own password. This minimizes the risk of a single compromised password putting your entire smart home at risk.

Mistake 2: Ignoring Firmware and Add-on Updates

Another major mistake that’s made frequently: not performing updates regularly. Home Assistant itself, as well as the devices you control with it, run on software that needs to be updated regularly – not just to get new features, but above all to close security vulnerabilities.

Why is this so important? Outdated software is a goldmine for hackers. When vulnerabilities become known – and this happens more often than you might think based on media coverage – attackers can specifically search for devices with those security gaps. One website, for example, automatically lists surveillance cameras found to be unprotected from access.

The good news: Home Assistant makes it easy to stay up to date. You can immediately see when updates are available on the dashboard. And with one click, you can install them. The same applies to custom components you’ve installed through the Home Assistant Community Store (HACS).

My tip: Schedule regular maintenance windows for your smart home – at least once a month. Set aside 15 minutes to apply all available updates for Home Assistant, your add-ons, and devices. This not only makes your system more secure but also ensures everything runs smoothly.

Mistake 3: Not Setting Up a Separate Network for Smart Home Devices

A common mistake many smart home users make: connecting all their devices – from lights to thermostats to cameras – to the same network used by their laptops, smartphones, and tablets. This sounds convenient at first, but it’s exactly what can become a problem.

What risks does this create? Smart home devices often have fewer security mechanisms than your laptop or smartphone. Many devices are only minimally secured or are based on older technologies that are vulnerable to attacks. If a hacker compromises a single device on your network – for example, a cheap smart plug or an unsecured camera – they gain the same access to your home network as a visitor in your home to whom you’ve given access to your private Wi-Fi.

The solution? Set up a separate network for your smart home devices. This sounds complicated, but it’s easier than you might think.

Most modern routers offer the option to create a so-called guest network. You can use this not only for visitors but also for smart home devices that communicate via the manufacturer’s cloud – because those are exactly the ones critical to the security of your home network.

Your Home Assistant installation, on the other hand, should be placed in your regular home network along with the smart home devices that don’t require internet communication. If you want to be extra safe, you can block those devices from accessing the internet through your router settings.

Some routers like FritzBoxes ([buy here – affiliate link])(https://amzn.to/3W6bgOr) or UniFi Access Points ([buy here – affiliate link])(https://amzn.to/4foMsb8) make it especially easy to set up guest networks and block access to the main network.

You can tell whether a smart home device communicates via the cloud in Home Assistant by checking the relevant integration. If it says “Dependent on the internet,” that integration and its associated device is such a candidate. Devices that don’t communicate with the internet but directly with your Home Assistant installation cannot be reached by a hacker from the internet and are therefore less critical.

Mistake 4: Not Using Two-Factor Authentication

A frequent mistake that often happens out of convenience or lack of awareness: not enabling two-factor authentication – or 2FA for short. Yet 2FA is one of the simplest and most effective measures to prevent unauthorized access to important systems like your Home Assistant installation and thus your smart home.

Why should you care? Imagine someone gets hold of your password – through phishing, a data leak, or because you reuse the password across services. Without 2FA, attackers can immediately access your Home Assistant and control your entire smart home: capture camera feeds, manipulate automations, or view sensitive data. With 2FA, however, they also need a second confirmation code generated only on your device – which makes it nearly impossible for hackers to hijack your account.

The good news: Home Assistant supports 2FA and makes setup straightforward. Simply go to Settings under Users and enable two-factor authentication. Use an authenticator app such as Google Authenticator, Authy, or Microsoft Authenticator. These apps generate new one-time codes every 30 seconds that you need to log in. Important: store the backup codes that Home Assistant generates in a safe place – for example, as a printout in a folder. This lets you recover your account if you lose access to the authenticator app.

My tip: Enable 2FA not just for your admin account, but for all users who have access to Home Assistant – especially for accounts other than your own. This gives you the assurance that nobody can unauthorized manipulate your system, regardless of the permissions of the associated user or how carelessly other users handle their passwords.

Mistake 5: Integrating Insecure or Unknown Devices into Home Assistant

One of the biggest advantages of Home Assistant is that you can integrate devices from a wide variety of manufacturers. This makes your smart home extremely flexible, but it also comes with risks. Many users buy cheap smart home devices from unknown or questionable manufacturers without checking how secure they actually are.

Why is this a problem? Insecure devices can act like a Trojan horse: if they are poorly programmed or intentionally built with backdoors, hackers can use these devices as an entry point into your network. Some cheap devices even send data unencrypted to servers you can’t control. This allows attackers not only to spy on your private data but also to gain access to other devices on your network.

The solution? Buy devices from reputable manufacturers: make sure they provide regular firmware updates and support established standards like Zigbee, Z-Wave, or Matter.

Check data transmission: use local integrations that communicate directly with Home Assistant, rather than devices dependent on a cloud. Platforms like Zigbee2MQTT or ESPHome are ideal because they give you full control over your data. Block unnecessary traffic: with tools like a modern router or firewall, you can prevent devices from communicating with the internet without authorization.

My tip: Be cautious with extremely cheap devices or products that offer little documentation or support. Infrequent updates can also be a warning sign. If you’re unsure, check reviews or community discussions about a device before buying – you’ll find out whether there are known vulnerabilities, whether the device should be considered potentially problematic, and how often updates are released.

Conclusion

Avoiding these five security mistakes takes you a big step toward a more secure smart home. Which security measures are you already using? If you have additional tips, feel free to share them in the comments.

These 5 Automation Mistakes Every Home Assistant User Has Made – Before security is solid, automations need to be reliable
5 More Home Assistant Automation Mistakes – Are You Affected? – Newer pitfalls around trigger IDs, script modes, and AI-generated automations

Show Errors & Warnings on Your Home Assistant Dashboard

Mon, 09 Dec 2024 00:00:00 +0000

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Forgot to water the plants again? The trash can is overflowing, the EV is empty? And the fridge door keeps getting left open? All while you have that data somewhere in your smart home? I’ll show you in three steps how to easily integrate a display like this into your Home Assistant dashboard so you never miss a warning again:

Prerequisites

For this tip you need to install the card-mod extension from the Home Assistant Community Store (HACS). Just open HACS in the sidebar, search for card-mod in the list of extensions, and click Download twice. Then reload the Home Assistant interface by clicking Reload — and the extension is ready to use.

Customizing the CSS Style

With this extension you can change the appearance of your dashboard elements. For example, to display a red warning card with white text instead of a neutral card, add the following YAML snippet to your card:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


card_mod:
 style: |
 ha-card {
 background-color: rgba(255,10,10,1);
 --primary-color: white;
 --paper-item-icon-color: white;
 --primary-text-color: white;
 --switch-checked-track-color: white;
 --switch-checked-button-color: white;
 }

The CSS variables used here (recognizable by the -- prefix) allow you to customize Home Assistant-specific elements such as icons or switch colors without needing in-depth CSS knowledge.

Enabling Conditional Display

Of course the cards should only appear when an actual error or warning is present. Use an entity-filter and define a condition. In this example, the fridge temperature should only be shown when it exceeds 8°C.

1
2
3
4
5
6


type: entity-filter
entities:
 - entity: sensor.kuhlschrank
 conditions:
 - condition: numeric_state
 above: 8

The complete definition looks like this, combining entities with conditions and our card-mod style:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


type: entity-filter
show_empty: false
entities:
 - entity: sensor.kuhlschrank
 conditions:
 - condition: numeric_state
 above: 8
conditions:
 - condition: state
 state: null
card:
 type: entities
 card_mod:
 style: |
 ha-card {
 background-color: rgba(255,10,10,1);
 --primary-color: white;
 --paper-item-icon-color: white;
 --primary-text-color: white;
 --switch-checked-track-color: white;
 --switch-checked-button-color: white;
 }

More Complex Example

You can of course group multiple entities together when they should be displayed in the same color, while still defining independent display conditions for each — like in this example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


type: entity-filter
entities:
 - entity: sensor.basilikum
 conditions:
 - condition: numeric_state
 below: 50
 - entity: input_boolean.mull_rausstellen
 conditions:
 - condition: state
 state: "on"
conditions:
 - condition: state
 state: null
card:
 type: entities
 card_mod:
 style: |
 ha-card {
 background-color: rgba(3,169,244,1);
 --primary-color: white;
 --paper-item-icon-color: white;
 --primary-text-color: white;
 --switch-checked-track-color: white;
 --switch-checked-button-color: white;
 } 

Color Hierarchy and Combined Conditions

A clear dashboard lives by a strong hierarchy that highlights important information while maintaining readability. I recommend structuring warnings and errors in your Home Assistant dashboard by color:

Red for critical errors (e.g. fridge temperature too high).
Orange for warnings (e.g. low battery level).
Blue for informational notices (e.g. take out the trash).

With this hierarchy you can assess the urgency of a situation at a glance.

Example: Three Groups with Different Warning Levels

Here is an example of a dashboard combining errors, warnings, and notices:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


type: vertical-stack
cards:
 - type: entity-filter
 show_empty: false
 entities:
 - entity: sensor.kuehlschrank
 conditions:
 - condition: numeric_state
 above: 8
 card:
 type: entities
 card_mod:
 style: |
 ha-card {
 background-color: rgba(255,10,10,1); /* Red */
 --primary-color: white;
 }

 - type: entity-filter
 show_empty: false
 entities:
 - entity: sensor.batterie_sensor
 conditions:
 - condition: numeric_state
 below: 20
 card:
 type: entities
 card_mod:
 style: |
 ha-card {
 background-color: rgba(255,165,0,1); /* Orange */
 --primary-color: white;
 }

 - type: entity-filter
 show_empty: false
 entities:
 - entity: input_boolean.muell_rausstellen
 conditions:
 - condition: state
 state: "on"
 card:
 type: entities
 card_mod:
 style: |
 ha-card {
 background-color: rgba(3,169,244,1); /* Blue */
 --primary-color: white;
 }

Hopefully you’ll never miss anything again!

What’s Next

Are you already capturing all the sensor data and information relevant to you in your smart home? What about wind speed? In my article Integrating Wind Meters with ESPHome into Home Assistant I show you how easy it is.

→ In a follow-up video I show four advanced methods for integrating warnings into your dashboard even more elegantly — completely without card-mod: 4 Smart Dashboard Tricks – So You Never Miss Anything Again

Making Garage Doors Smart with Shelly

Wed, 27 Nov 2024 00:00:00 +0000

I had an old Shelly 1 lying around and a garage door I still had to open with a remote control – like it was 20 years ago. One afternoon later, that was sorted. The door has been opening via app, via automation, and when needed even from vacation ever since.

This was roughly my third video on the channel. I had no big expectations – and it turned out to be the most-watched video I’ve ever published. Apparently this is a topic a lot of people care about. If you want to see what I did with it a year later, check out Smart Garage 2.0 afterwards.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

Prerequisites

All you need is a smart relay – a small switch that can be controlled electronically. In my case that’s an old first-generation Shelly 1 I had lying around. New Shellys are available for around €10 (buy here – affiliate link, or directly at Shelly: buy here – affiliate link, code SMARTHOMEABERSICHER-10OFF for 10% off). If you want to not just open but also close your garage door – because it doesn’t do that automatically – then two Shellys with one output each, such as two Shelly 1 Mini Gen3 (buy here – affiliate link, or at OBI: buy here – affiliate link, or directly at Shelly: buy here – affiliate link, code SMARTHOMEABERSICHER-10OFF for 10% off), are the better choice. These can also run on 12V/24V DC and can therefore be powered directly from the door controller’s power supply.

You’ll also need to spend a bit of time researching the correct way to wire the relay to your specific garage door. I’ll explain how to do that without deep electronics knowledge – and how I did it for my garage door – in the sections below.

Finally, make sure you have Wi-Fi coverage at your garage door, or if your smart relay uses Zigbee or Bluetooth, that you have adequate signal there.

How It Works

Garage doors can often be opened via a key switch on the outside of the door or push buttons and pull cords on the inside. There are also usually proprietary wireless remotes. The buttons and switches are typically connected to what’s called a potential-free contact on the door controller. This means these contacts carry no current until they are activated by closing the switch – they work essentially like a simple light switch that doesn’t pass current until someone presses it. Wireless remotes work on the same principle: the remote’s receiver ultimately closes one of these contacts to trigger the door to open. We can use this to our advantage by simply connecting our Shelly in parallel to the door controller, so the Shelly becomes an additional way to control the door.

Let’s take a closer look at the exact wiring. Here we can see the key switch connected to the switching contacts, which are bridged when the key is turned. We can connect the Shelly in exactly the same way – in parallel to the existing wiring. Of course, the Shelly also needs power. Here we take advantage of the fact that the garage door controller’s power supply typically provides 12V or 24V for accessories via dedicated contacts in the housing. It’s convenient that the Shelly can run on 12V or 24V DC, making this connection safe even for non-technical users.

Installing the Shelly

So we need to find two suitable contacts through which the Shelly can control the garage door, plus two connections for the Shelly’s power supply.

I’ll walk you through this using my own door controller as an example: a TS 971 by GfA Elektromaten. But the approach is always the same.

Let’s look at the technical manual for the garage door, which I found on the manufacturer’s website without much searching – all the relevant information is printed right there. On page 14, under the heading “Push button/Radio receiver”, you’ll find what we need:

Here you can see that the key switch is connected to contacts 7.1 and 7.2. You can also see that 24V DC is available via the 24V and GND contacts.

Once you’ve found suitable contacts for power and for triggering the opening and/or closing, you can simply connect the Shelly. Concretely: connect the “I” and “O” terminals of the Shelly to contacts 7.1 and 7.2 on the door controller, and connect “N” to 24V and “L” to GND. Ideally there’s even space inside the existing housing, as was the case for me:

Note: For the Shelly 1, move the power supply jumper for 12V DC operation – those little jumper bridges under the cover. If your door runs on 24V, it can be left unchanged.

Source: https://kb.shelly.cloud/knowledge-base/shelly-1

If you’re using a newer Shelly 1 Plus, it has separate terminals depending on the voltage, so no jumpers need to be changed.

Conclusion

And that’s it – you’ve successfully integrated your garage door into your smart home. The Shelly can now be controlled flexibly, either via the Shelly app or through your preferred smart home hub. Ideally also remotely over the internet.

This means your garage door can finally be opened when you’re still a street or two away, with far greater range than a traditional remote. But make sure the Shelly setup is just as secure as your front door! Access must be well protected so that nobody can gain entry to your garage – and potentially your home.

That means:

a strong password
up-to-date firmware
no open ports to the internet
and ideally a VPN connection or SSH tunnel into your home network

Of course, other smart relays can be used instead of Shellys. Get creative and find the best solution for your situation! And if you can’t find a way to wire up a relay at all, a Switchbot (buy here – affiliate link) might also be an option for you.

Questions about wiring or security configuration? Drop them in the comments – the garage door topic has an active community, and most problems have already come up there before.

Smart Garage 2.0: Garage Door, Lights & Automations with Shelly Blue – One year later: my complete garage upgrade with motion sensors, wallbox automation, and CarPlay control
Making Roller Shutters Smart with Shelly – The same principle for blinds: Shelly local, no cloud
No More Annoying Thermostats! Shelly Makes Your Heating Smart – More Shelly in action: this time for heating control

Integrating Wind Sensors with ESPHome into Home Assistant

Mon, 25 Nov 2024 00:00:00 +0000

My awning gave me quite a fright once. A storm rolled in faster than expected — and I wasn’t home. When I got back, it was still up, but just barely. Clearly, the awning needed a wind sensor. The manufacturer conveniently had a solution ready — for €200. For a single sensor.

That was out of the question. An ESP8266 microcontroller, a wind sensor (anemometer) for around €20, and ESPHome solved the problem for a tenth of the price. Since then, the awning retracts automatically when the wind gets too strong — and I no longer have to worry about it.

To load the video, please click the image. Please note that by doing so, data will be transmitted to YouTube.

What You’ll Need

To get started, you only need a few components:

An ESP8266 microcontroller (buy here* - affiliate link)
A wind sensor/anemometer (buy here* - affiliate link)
A 5V power supply (e.g., an old phone charger)
ESPHome (already installed)
Your smart home hub — in this example, Home Assistant

If you’re not yet familiar with ESPHome, I recommend checking out this introduction first.

Measuring Wind

The anemometer measures wind movement via rotations. Each rotation generates electrical pulses that the microcontroller captures. Using a formula defined by the sensor model, the current wind speed is calculated and transmitted via Wi-Fi to your smart home hub.

Wiring

Connect the cables of the wind sensor to the GPIO pins of the microcontroller. Use a standard 5V power supply to power the microcontroller — an old phone charger works perfectly. Important: Note which GPIO pin the wind sensor is connected to, as you’ll need this information later for the configuration.

Software Setup — Programming with ESPHome

Creating the Basic Configuration

Start with a simple configuration file in ESPHome. It contains the basic information your microcontroller needs, such as:

The device name (e.g., “windsensor”),
The platform (ESP8266 or ESP32, depending on your microcontroller),
Wi-Fi settings (SSID and password of your network).

All of this happens in lines 1–26 below.

Defining the Sensor for the Anemometer

The wind sensor is configured as a pulse_counter. This module counts the pulses and calculates the wind speed using a filter (starting at line 37). We use the formula provided by the manufacturer in their documentation and apply it here as a lambda function in the sensor definition (line 62).

Calculating Averages and Wind Gusts

In addition to the current wind speed, average values and maximum wind speeds (gusts) are particularly useful. For this, you use template sensors with appropriate filters.

Average value (sliding_window_moving_average): Calculates the mean wind speed over the last 30 minutes (line 81)
Maximum value (max): Stores the highest speed over the last 5 minutes (wind gusts) (line 96)

Here is the complete configuration:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98


esphome:
 name: windspeed
 friendly_name: Windmesser

esp8266:
 board: nodemcuv2

# Enable Logging
logger:

# Home Assistant API, required so Home Assistant can access the microcontroller
api:
 encryption:
 key: "xxx"

ota:
 - platform: esphome
 password: "xxx"

web_server:
 port: 80

wifi:
 ssid: !secret wifi_ssid
 password: !secret wifi_password

# Definition of the sensors that are provided as entities in Home Assistant
sensor:
 # Sensor showing the WiFi signal strength of the microcontroller
 - platform: wifi_signal
 name: "WiFi Signal"
 update_interval: 60s
 # Sensor showing the uptime of the microcontroller
 - platform: uptime
 name: Uptime 
 # Measurement of the current wind speed using "pulse_counter"
 - platform: pulse_counter
 name: 'Wind Speed Realtime'
 icon: "mdi:windsock"
 id: wind_speed
 unit_of_measurement: 'km/h'
 device_class: wind_speed
 state_class: measurement
 # Frequency at which the wind sensor signal is checked
 internal_filter: 1us 
 # Frequency at which the wind speed is updated in Home Assistant
 update_interval: 1s
 accuracy_decimals: 1
 # Wiring of the wind sensor
 pin:
 number: D5
 inverted: true
 mode:
 input: true
 pullup: true
 # Provides an additional entity with the total pulse count (useful for debugging only)
 total:
 name: "Total Pulses"
 # Calculates wind speed using the manufacturer's formula: Wind speed (km/h) = 0.8*Hz + 3
 # The filter definition computes the wind speed using this formula
 # The input variable x corresponds to the number of "pulses per minute"
 filters:
 - lambda: !lambda |-
 if (x == 0) return 0;
 return (x/60)*0.8+3;
 - min:
 window_size: 2
 send_every: 1
 # Sensor providing the "average wind speed"
 - platform: template
 name: "Wind Speed Average"
 icon: "mdi:windsock"
 unit_of_measurement: 'km/h'
 device_class: wind_speed
 state_class: measurement
 lambda: |-
 return id(wind_speed).state;
 update_interval: 1s
 # Definition: wind speed = average wind over the last 30 min
 filters:
 - sliding_window_moving_average:
 window_size: 1800
 send_every: 1
 # Sensor providing the maximum gust speed
 - platform: template
 name: "Wind Speed Gusts"
 icon: "mdi:windsock"
 unit_of_measurement: 'km/h'
 device_class: wind_speed
 state_class: measurement
 lambda: |-
 return id(wind_speed).state;
 update_interval: 1s
 # Gust = instantaneous maximum speed within the last 5 min
 filters:
 - max:
 window_size: 300
 send_every: 1

Flashing the Configuration

Open ESPHome and connect your microcontroller via USB. Click “Install” and upload the configuration. Once the microcontroller has been programmed once, future updates can be flashed wirelessly (“Over the Air”).

Integration into Home Assistant

ESPHome makes integration particularly straightforward:

Open Home Assistant.
Navigate to “Settings > Integrations > Add Integration”.
Select “ESPHome” and enter the IP address of your microcontroller.
Enter the encryption key from your ESPHome configuration.

Once the integration is complete, you can view the recorded values (current speed, average, gusts) in Home Assistant and use them for automations.

What’s Next

With the collected wind data, you have a wide range of control options, for example:

Automatically retract awnings when a critical wind speed is reached.
Close roller shutters to protect windows during storms.
Send warning notifications when extreme weather conditions are approaching.

Do you have questions or other ideas for what you can do with wind data? Write them in the comments — I’m curious what you’ll build with this.

Posts on Smart Home? Sure — But Secure!

I Made My Range Hood Smart – For the Second Time

The problem: the quietest range hood in the world

2017: The hack in the cable

Eight years – with a safety net

My first KiCad project – with an AI coach

The mystery of the old board

Ordering, assembling, fixing

Result

Shelly Gen1 to Gen4: What Really Changed – and Why My 2.5s Are Going

Why repairing no longer pays off for me

Four generations at a glance

Gen1: the brilliant idea

Gen2 (Plus): Bluetooth, scripts, slats

Gen3: skipped

Gen4: Matter and Zigbee built in

The terminals: different in every generation

The swap

The mishap: a broken wire

Calibrate and flip the direction

The Matter QR code – twice

Setup: Matter instead of an open hotspot

Three tips for the swap

Conclusion

Products from this article

Shelly via Matter was broken – so I fixed it in Home Assistant

The symptom: device yes, shutter no

The clue: the venetian blind

The cause

Whose fault is it?

The fix

What you need to do now

Your opinion matters

Products from this article

b-parasite: Have an Open-Source Soil Moisture Sensor for Home Assistant Manufactured

What is the b-parasite?

Step 1: Ordering the board – no KiCad skills required

How to place the order

What does it cost?

Pitfall: no voltage at the battery pad

Step 2: Flashing the firmware with an ESP32

Tip: convert HEX to BIN

Step 3: Adding it to Home Assistant

Step 4: Coating against moisture

Hands-on test: how good are the readings?

Moisture percentage is not an absolute value

Battery life: extrapolation doesn’t work

Radio gaps

Verdict: is it worth the effort?

Giveaway: 3 b-parasite sensors

Links

Tilt Venetian Blind Slats to the Percent with Shelly and Home Assistant

Position and tilt: two independent values

Backstory: my ugly workarounds

Shelly setup: Slat Control

How I found the feature: a Matter bug

In Home Assistant: attribute and action

Important: move first, wait, then tilt

Automation 1: sun protection based on the sun’s position

Blueprint A: is the sun hitting the window?

Blueprint B: close the blind and tilt the slats

Automation 2: wake-up routine with daylight

My takeaway

My Radio Mutes Its Own Ads

The station gives it away itself

Step 1: Find your station’s marker

Step 2: Two triggers, one if

If your station isn’t quite so unambiguous

One automation per speaker

Ten days of recording: what does it actually do?

Where the limits are

Conclusion

Make Your Doorbell Smart Without Disturbing the Neighbors (Siedle + ESPHome)

Why not just buy a ready-made solution?

The principle in one sentence

Detecting the ring: the voltage trick

Opening the door: press the button instead of rebuilding the protocol

The hardware: compact and cheap

ESPHome: three details that matter day to day

The payoff: four entities in Home Assistant

Step 2: Two triggers, one `if`