Our Home Automation Project

Chapter 1 — It All Started with a Meter

I hadn't exactly set out to automate the house.

I simply received a letter telling me that my electricity meter was going to be replaced with a smart meter.

Obviously, I couldn't just accept that piece of information and leave it at that.

A smart meter. Fine. But what exactly does it communicate? To whom? How? What data is available? And, most importantly: can I access it myself?

A bit of research later, I learned that I could check my electricity consumption "live" through the grid operator's website.

"Live" definitely deserves those quotation marks: the data can be delayed by at least fifteen minutes.

Noted.

Digging a little deeper, I discovered something much more interesting: the meter has a port that, with the help of a small dongle, can provide direct local access to the consumption data.

And, well...

I want that.

Not necessarily because I need it. But because the data is right there, in my house, generated by a device installed in my house. Being able to access it directly, store it and process it however I want seems considerably more interesting than relying on a third-party service, its app and its limitations.

And, obviously, what was supposed to be a simple meter replacement didn't go entirely according to plan.

→ A Smart Meter, a P1 Port and a Few Misadventures

And then there are the solar panels.

Having real-time access to both the house's electricity consumption and the energy being fed back into the grid immediately opens up a few possibilities: why not use that information to control certain devices depending on how much energy is available?

At the time, though, there wasn't much of an economic incentive for me to do so. Under the prosumer scheme I was still benefiting from, the grid essentially behaved like a gigantic virtual battery: what I fed into it offset what I drew from it later.

But that system wasn't going to last forever.

So it was an excellent excuse to start figuring out how all of this worked and prepare for what came next.

There was, however, one small problem.

If I was going to start collecting data from the meter and then add devices capable of reacting to that data, I had absolutely no desire to end up with a collection of proprietary apps, each tied to a different manufacturer or cloud service.

I wanted something I could control.

Something local.

Something I could modify, connect to other things and, most likely, break from time to time.

Home Assistant quickly became the obvious choice.

At first, it was simply a matter of seeing whether I could use it to retrieve data from the meter and a few devices. Obviously, it didn't really stop there.

→ Home Assistant? What Is This Thing?

And that was roughly the point when a simple question about a new electricity meter started turning into a project to automate the entire house.

One thing leading to another...

Chapter 2 — What If We Turned On a Light?

When you start thinking about home automation, it usually doesn't take very long before someone mentions lighting.

And of course, I was no exception.

It wasn't entirely new territory for me either. I'd heard plenty about Philips Hue, experimented with a few smart bulbs, and we already had a couple of lights that could be controlled remotely, albeit in a fairly limited way.

The principle was generally the same: the wall switch still turned the light on and off, while dimming, changing colours or accessing the slightly more advanced features required either a remote control or an app.

It worked.

But I'd never found it particularly convincing. Between occasional configuration losses, having to pair them again, and needing to pull out a phone to access certain features, I'd never really felt like taking things much further.

On the other hand, all of that had given me a fairly clear idea of what I wanted.

The solution had to be reliable, integrate properly with Home Assistant and not require regular reconfiguration. If updates were needed, being able to manage them easily — ideally from Home Assistant — would obviously be a bonus.

But above all, the house still had to work like a house.

A light switch had to remain a light switch.

You press it, the light comes on. Whether Home Assistant is available or not.

Home automation was supposed to add possibilities, not take existing ones away.

With those few requirements in mind, I started looking at what was available.

And fairly quickly, I came across the small Sonoff modules designed to fit behind a wall switch.

Compact — at least compared with some of the other solutions I'd seen — reasonably affordable and with generally positive reviews, they looked interesting enough to justify an experiment.

They communicated over Zigbee.

And rather than putting me off, that was actually a point in their favour.

I'd heard about Zigbee regularly over the years without ever having much reason to look into it more closely. But using a protocol specifically designed for this kind of device seemed fairly natural to me.

If the project was eventually going to involve a few dozen modules, sensors and other small devices scattered around the house, having a dedicated network for them seemed more sensible than putting everything directly on Wi-Fi.

And Zigbee had been around long enough to inspire a certain amount of confidence.

So my extremely thorough analysis probably went something like this:

"It's been around for quite a while. It must be mature by now."

Thinking back, the choice of the Sonoff module itself probably didn't involve much more analysis.

The form factor looked good, the feedback seemed positive, and the entry price was low enough that it wouldn't be a big deal if the experiment went nowhere.

I mostly saw it as a mini-project.

Install one, see how it works and, more importantly, see if it works well.

There was still the question of how Home Assistant was actually going to communicate with it.

And two names kept coming up: ZHA and Zigbee2MQTT.

I wanted to turn on a light and I already had an architecture decision to make.

→ ZHA or Zigbee2MQTT?

Once that decision was made, all that remained was to install the first module.

→ Installing and Integrating a Sonoff Zigbee Module Behind a Wall Switch

Getting the first Sonoff modules properly integrated turned out to be slightly less straightforward than expected. There were a few subtleties in how they worked — and in their documentation — that had to be understood first.

But once those were figured out, the process became relatively simple and, more importantly, repeatable.

As for Zigbee, my rather approximate reasoning turned out not to be too far off. So far, it has caused me practically no trouble at all.

Devices stay connected, the network works, and I don't have to think about it.

Exactly what I expect from this kind of technology.

My later experiments with Thread and Matter would be... let's say, a little more adventurous.

But that's another story.

So the little "let's see what happens" project had been a success.

Successful enough, at least, that the first Sonoff module didn't stay alone for very long.

Chapter 3 — Technically Possible

By this point, things were going rather well.

Home Assistant was working, Zigbee had proved surprisingly trouble-free, and the first lights had been automated without turning the house into a place where you needed to pull out your phone just to switch on a lamp.

But being able to control a device from Home Assistant was ultimately only the most visible part of what I was looking for.

Pressing a button in an interface instead of one on the wall or on a remote control is convenient.

It isn't necessarily automation.

What was becoming much more interesting was making the house react to what was happening around it.

And for that, we had two obvious candidates: the blinds.

We already had two motorised blinds controlled by radio. The goal wasn't simply to open or close them from Home Assistant, but to make their behaviour depend on information Home Assistant already had: the time, the day of the week, brightness, the outside temperature...

On paper, there wasn't much missing.

I "just" had to figure out how to talk to them.

I knew that capturing a radio signal, analysing it and potentially reproducing it was technically possible. So I was fairly confident: with a bit of hardware, some research and enough time, there had to be a way to integrate those blinds properly.

What was supposed to be a small integration gradually turned into an exploration of a proprietary protocol that was considerably more sophisticated than expected.

I would have liked to find an elegant solution. I was even fairly convinced that one existed.

But between what is technically possible and what is reasonable to do simply to open and close two blinds, my optimism was about to get a fairly serious reality check.

→ Two Blinds, AES and Six Relays Later

In the end, the objective had been achieved: the blinds could now become part of the house's automations.

But I had also learned a fairly concrete first lesson: in home automation, knowing that something is technically possible doesn't necessarily mean there is a simple, clean and reasonable way to do it.

Sometimes you also have to work with what is already there — and accept that the final solution may not be the one you originally had in mind.

Fortunately, not every idea turns into an exploration of proprietary protocols.

Some even work almost exactly as imagined.

A very simple example: the lighting when we come home.

Home Assistant knows the position of both our cars. When one of them comes within 100 metres of the house, and we're at least fifteen minutes before sunset or later, the driveway lights switch on for seven minutes.

One minute later, the entrance hall light comes on as well, also for seven minutes.

Nothing particularly spectacular.

But when we come home in the evening, the driveway is already lit as we arrive, and the house is waiting for us with the entrance hall light on.

There's nothing to do, nothing to ask for and no button to press.

This little automation will probably become the subject of a future short. It's simple, but it illustrates rather well what I was trying to achieve with Home Assistant.

Not necessarily the ability to control everything from an interface.

But the ability to take information from systems that originally had very little to do with one another — a car, the time of sunset, some lights — and make them work together to produce behaviour that suits the way we actually use the house.

Sometimes that takes far more effort than expected.

And sometimes a few rules are enough to make the house simply do what you'd like it to do.

Chapter 4 — And Now, Thread and Matter

Thread and Matter didn't appear in the house simply because I'd decided it was time to try something new.

As so often since the beginning of this project, there was a much more concrete need behind it.

We had been thinking for a while about installing a smart lock.

After looking at the different options, I eventually settled on a Nuki Smart Lock Pro.

I won't go into the reasons behind that choice or the installation here — that will probably be the subject of another short — but the result surprised us fairly quickly.

The lock works very well with its app and widgets. More importantly, something that could easily have seemed like a gadget at first turned out to be far more useful in everyday life than we'd imagined.

Obviously, I'd planned from the start to integrate it with Home Assistant as well.

And there were several ways to do that.

Wi-Fi was one of them.

Thread and Matter were another.

Both approaches could achieve the result I wanted, but there was one difference that particularly interested me: the choice of communication protocol had a direct impact on the lock's battery life.

Thread suddenly became much more than an interesting technology to experiment with.

There was a real reason to use it.

One small problem:

I didn't have a Thread Border Router.

On the other hand...

I had ESPs.

Including an ESP32-C6.

It supports Thread, so in my mind the equation was fairly simple: if I needed a Thread Border Router and the C6 could speak Thread, why not build one with it?

That was the original idea, anyway.

One of those Hannibal Smith-style plans that, on paper, obviously couldn't fail to come together.

Digging a little deeper, things turned out to be somewhat less straightforward.

My one-ESP project was eventually going to require two: the C6 to handle communication with the Thread network, and an ESP32-S3 to provide the link to the house's IP network.

Right.

The plan had evolved slightly.

All that remained was to make the whole thing work together.

→ Building a Thread Border Router with Two ESP32s

And it worked.

I now had my own Thread network and, more importantly, a new integration option for devices that might find their way into the house.

Zigbee hadn't done anything wrong.

It was still working just as well as before, and there was absolutely no question of replacing it.

Thread was simply joining it because a particular device and a concrete need had made it relevant.

And since I now had a working Thread network at home, it was also an excellent excuse to try out a few new toys.

A visit to IKEA happened to come at just the right time.

With a few sensors and a Thread/Matter switch, I was going to get a more concrete first impression of this new generation of devices.

On paper, the promise is appealing: a common standard, devices from different manufacturers capable of working together, and a Thread network designed specifically for this kind of use.

In practice...

Let's just say the experience turned out to be a little more educational than expected.

→ She Just Wanted a Switch

None of this made me want to give up on Thread or Matter.

But it did remind me of something that Zigbee, after years of existence, had almost made me forget: between a promising technology and one that has become completely ordinary to use, there can be a transition period that is rather... interesting.

And ultimately, that wasn't really a problem.

Zigbee kept doing its job.

Thread and Matter simply added more possibilities.

That's actually becoming fairly characteristic of this project.

I never really decided to build a "Zigbee", "Thread" or "Matter" house, or anything else for that matter.

A need appears.

I look at the possibilities.

And every now and then, the answer involves one or two ESPs lying around in a drawer.

---

Update

24/09/2026 — Added Chapters 3 and 4, along with a few minor corrections throughout the text.