Markus Haack // Software Engineer

DA MCP: Giving AI Assistants Direct Access to Document Authoring

2026-03-16T00:00:00Z

Over the past few months, AI assistants have gone from useful chat tools to something more interesting: agents that can actually do things. Not just draft text, but read files, write content, move things around, and connect to external systems. The key technology making this possible is the Model Context Protocol (MCP) — an open standard for giving AI tools structured access to external services.

I’ve been working deeply with Document Authoring (DA) — Adobe’s content platform for Edge Delivery Services — and I kept thinking about the same question: what if Claude could just talk to DA directly? Not through copy-pasting, not through a browser, but as a first-class tool in a conversation?

So I built it.

What is DA MCP?

DA MCP is a remote MCP server that gives AI assistants like Claude or ChatGPT direct access to DA management operations. Once connected, your AI assistant can browse your DA repositories, read and write files, create new pages, move content around, check version history, and look up media and fragment references — all without leaving the chat window.

Think of it as giving your AI assistant a command-line-like interface to DA. Instead of switching between tools and copying content back and forth, you can say things like:

Draft a new landing page at /products/overview and save it directly to DA.

Create 5 event pages with details for the provided CSV file.

And it just does it.

The 10 Tools

DA MCP exposes 10 tools covering the full content lifecycle:

Tool	What it does
`da_list_sources`	Browse directories and list files in a repository
`da_get_source`	Read the full content of any file
`da_create_source`	Create a new file with provided content
`da_update_source`	Update an existing file in place
`da_delete_source`	Delete a file
`da_copy_content`	Copy content from one location to another
`da_move_content`	Move or rename content
`da_get_versions`	View version history for a file
`da_lookup_media`	Look up media asset references
`da_lookup_fragment`	Look up content fragment references

How It Works

The server is built in TypeScript and runs on Cloudflare Workers. Authentication uses a token pass-through model — the client sends a DA Admin API token in the Authorization header, which the server forwards to the DA Admin API. If you use the public endpoint at mcp.adobeaemcloud.com, Adobe IMS authentication is handled automatically. No token configuration needed.

The code is open source: github.com/adobe-rnd/da-mcp. Pull requests and feedback welcome.

Getting Connected

Claude.ai is the easiest way to start. Go to Settings → Connectors, find DA MCP, click Connect, and sign in with your Adobe IMS account. Done.

For Claude Desktop, add this to your config file — on macOS: ~/Library/Application Support/Claude/claude_desktop_config.json, on Windows: %APPDATA%\Claude\claude_desktop_config.json:

{
  "mcpServers": {
    "da-mcp": {
      "type": "streamable-http",
      "url": "https://mcp.adobeaemcloud.com/adobe/mcp/da"
    }
  }
}

For VS Code or Cursor, add to .vscode/mcp.json:

{
  "mcpServers": {
    "da-mcp": {
      "url": "https://mcp.adobeaemcloud.com/adobe/mcp/da"
    }
  }
}

What I’ve Been Using It For

I’ve been running this day-to-day for a few weeks. A few things work well: drafting and saving content without leaving the conversation, bulk updates across multiple pages without writing scripts, and using da_get_versions to check what changed in a file without context-switching. Combining it with web research is also useful — Claude can look something up and save the result to DA in one pass.

A Real-World Example

A colleague posted a good example on LinkedIn: auditing Summit Labs for missing content pages, scaffolding them out from a CSV export — all in a single conversation, saving around 6 hours of manual work. That’s the kind of multi-step workflow where having Claude directly connected to DA pays off.

Our 2025 Home Solar Performance: 5 Years of Real Data

2026-03-07T00:00:00Z

If you want to know if it makes financial sense to install a home solar system in Germany, or if you’re curious about how long these systems last, we have the answers for you. Here is five years of real data from our own rooftop PV system in Germany. In 2025, our 9.45 kWp system produced 8,624 kWh, covering 54% of our household electricity needs and saving us around €2,200 in grid costs. The full breakdown is below.

This is our fifth annual solar review. You can find the previous ones for 2024 and 2023, along with the original installation posts from 2021. Quick system overview: 9.45 kWp of panels on a south-facing roof in southern Germany, installed in 2021, paired with a BYD battery and a SolarEdge inverter. Since mid-2025 we also have a Polestar 4 that we charge primarily on solar surplus using evcc.

2025: Steady Production, Higher Consumption

Our panels produced 8,624 kWh in 2025 — down just 0.9% from 2024. Essentially flat. Total household consumption climbed to 10,714 kWh, a 6.3% jump compared to the previous year. The new EV is almost certainly responsible for a big chunk of that.

The seasonal pattern was familiar:

Best month: June, with 1,291 kWh — narrowly edging out May (1,260 kWh). For the first time in five years, June rather than July claimed the top spot.
Worst month: January, as expected — just 169 kWh in a month where we consumed over 1,000 kWh. Very similar to the previous years.
Most grid-independent months: July and June, where we drew only 104 kWh and 161 kWh from the grid respectively.

What was different compared to 2024? Spring was notably stronger — February was up +55 kWh, May up +99 kWh. But July let us down badly: 1,074 kWh against July 2024’s 1,299 kWh, a drop of 225 kWh. October was similarly disappointing (352 kWh vs. 482 kWh in 2024). Whatever the weather was doing in those months, it hit the panels hard.

The flip side: December 2025 was almost double December 2024 — 166 kWh versus 85 kWh. That continues a pattern we’ve been watching for a few years now: milder winters, less snow cover on the panels, marginally better winter yields. Not much but it adds a little to our electricity savings.

Five Years in One Table

Year	Production	Consumption	Grid Purchased	Self-consumed	Solar Coverage
2021	8,065 kWh	9,926 kWh	4,549 kWh	5,378 kWh	54%
2022	9,320 kWh	10,322 kWh	4,482 kWh	5,840 kWh	57%
2023	8,459 kWh	10,143 kWh	4,827 kWh	5,317 kWh	52%
2024	8,706 kWh	10,078 kWh	4,661 kWh	5,418 kWh	54%
2025	8,624 kWh	10,714 kWh	4,953 kWh	5,761 kWh	54%

A few things stand out. 2022 was our best year by a wide margin — an exceptional spring that has never been repeated. Since then we’ve settled into a band of 8,400–8,700 kWh, which is probably where we’ll stay barring unusual weather.

The column I pay most attention to is self-consumed solar — up from 5,378 kWh in year one to 5,761 kWh in year five, a 7% increase even though production has barely moved. The battery is doing its job. Our Eigenverbrauchsquote (to use one of our famous long German words) aka. the solar coverage ratio has been remarkably stable at 52–57% across all five years, landing at 54% in three of those years.

The Financial Reality

German residential electricity prices averaged around €0.38/kWh in 2025 — still the highest in the EU despite a slight easing from the 2023 peak of €0.47/kWh. Our current electricity contract is slightly lower at €0.29/kWh, however every kWh we produce ourselves is worth substantially more than when we installed the system.

In 2025 we self-consumed 5,761 kWh of solar energy, representing €2,189 in avoided grid costs. We also exported 2,833 kWh back to the grid at the current feed-in tariff of ~7.9 ct/kWh, adding around €224 in income.

Total 2025 benefit: roughly €2,400.

Over five years, we’ve self-consumed approximately 27,700 kWh in total. Even at a conservative blended average of €0.30/kWh (accounting for lower prices in the early years), that’s around €8,300 in cumulative grid savings — plus another around €1,000 in feed-in revenue across the period.

The system is approaching the midpoint of its expected 20-year lifespan. At current benefit rates, we remain on track for a full payback well within that window.

How We Compare to Other German Systems

For southern Germany, the typical annual yield benchmark is 1,000–1,200 kWh per kWp of installed capacity for ideally oriented systems. We live roughly in the middle of the country, where the forecast figures are somewhat lower. Our 9.45 kWp system produced 8,624 kWh in 2025 — a specific yield of 912 kWh/kWp. Our real-world yield reflects the actual installation geometry of our four-sided roof, with only the east, south and west sides covered by solar panels.

Our 66.8% self-consumption rate places us well within the range for battery-equipped residential systems. Fraunhofer ISE reports that self-consumption in Germany rose from 13% to 17% of total PV generation in 2024, driven by growing battery storage adoption. Systems with batteries typically reach 60–80% — we’re in the top portion of that range. Without a battery, systems self-consume 25–35% of their production — an example of why the battery pays for itself in terms of system efficiency.

What’s Next

We had a smart meter installed at the end of 2025. The next step is obvious: switch to a dynamic electricity tariff. I’m not 100% sure yet, but with our battery and EV charging, we’re in a good place to make the most of changing prices.

Regarding the system itself, after five years the panels show no obvious signs of degradation, the battery is in good condition and the SolarEdge inverter is working fine. Sometimes the best update is that everything just works.

FAQ

How much electricity does a home solar system produce per year?

Ours produced 8,624 kWh in 2025 — roughly what a typical German household consumes in a year. For us that’s no longer enough, since adding an EV pushed our annual consumption to over 10,700 kWh. We have 9.45 kWp installed; a typical single-family home in Germany can fit 10–12 kWp depending on roof size and orientation. The theoretical benchmark for a well-sited system is around 1,000–1,200 kWh per kWp installed.

Is a battery worth adding to a home solar system?

For us, clearly yes. Without a battery we’d self-consume maybe 25–35% of what we produce — the rest goes to the grid at the low feed-in rate. With our 10.5 kWh battery we’re at 66.8%. It shifts solar production from midday, when we don’t need it, to mornings and evenings, when we do. Five years in, that call still looks right.

How much money can a home solar system save per year in Germany?

In 2025 our system saved us around €2,400 in total: €2,189 from not buying that electricity from the grid, plus €224 in feed-in income. With grid prices at €0.38/kWh — and our own contract at €0.29/kWh — every kWh we produce ourselves is direct money saved. Five years in, the annual benefit has grown every year as prices have risen.

This post is part of my annual solar performance series. Previous years: 2024 · 2023

Migrating from Plausible to Pirsch Analytics using Netlify Edge Functions

2025-12-20T00:00:00Z

I’ve been a happy Plausible Analytics user for quite some time. The UI is clean, the solution is privacy-focused, and does exactly what it’s supposed to do. Honestly, there was no technical reason to switch — until we exceed the current subscription plan.

Lately, my websites — this one and the dinosaur website of my daughter have seen a nice increase in traffic, consistently exceeding the 10k monthly pageview limit. While this growth is great, Plausible’s pricing model is a bit steep for hobby projects. The next tier with 100k monthly pageviews jumps straight to €190 + VAT (up from €90 + VAT). With both sites together receiving around 12,000 page views per month, there is certainly plenty of room for growth. However, I don’t think we’ll reach 100k in the next five years.

That’s why I decided to move to Pirsch.io. The analytics features offered by Pirsch.io are comparable with those offered by Plausible. Both tools are privacy-focused, no-cookie analytics solutions. Fortunately, both providers offer good documentation. This makes comparison easy, as does subsequent migration. The way in which website visitors and page views are counted is quite similar. Pirsch.io has slightly better bot detection, or at least better documentation of it. Otherwise, I can’t see any major differences.

Plausible is certainly the more popular provider of the two, while Pirsch.io is the niche player from Germany. But in terms of pricing, Pirsch.io beats Plausible. They also offer a 100k plan for €120 + VAT per year. While the 10k page view plan is at €60 + VAT per year.

The Migration

The transition was remarkably smooth. Pirsch provides a built-in import tool for historical data from Google Analytics, Plausible Analytics and Fathom Analytics, so I didn’t lose any of my existing stats.

I was able to import all historical data from Plausible simply via a CSV file.

Setting up Pirsch Analytics

Setting up Pirsch Analytics is really easy.

Once you have created your account, generate a tracking script via the Pirsch dashboard. You only need to provide the hostname of your website, an optional subdomain and a time zone. Once you have created your dashboard, you can select from the integration options. Finally, you will receive a custom JavaScript snippet specific to your website, which you should copy and paste into the <head> section of your website.

There are also a large number of ready-made integrations for CMS (such as WordPress), e-commerce platforms (such as Shopify) or SSG frameworks (via Astro or Gatsby) available from the community.

I went for a more advanced option via a bumpy round.

Using a Proxy with Netlify Edge Functions

I prefer to serve my analytics script through a proxy on my own domain. This ensures first-party data collection and helps bypass common ad-blocker issues. I have already used this pattern for my previous Plausible Analytics integration.

Pirsch offers this proxy via a custom subdomain, but only with the Plus subscription. For those of us who want to save money, they provide self-hosting proxy options in three different languages. PHP, Go and JavaScript.

Since my sites are hosted on Netlify, I wanted to leverage Edge Functions for this. The Pirsch documentation includes a JavaScript Cloudflare Worker proxy guide, but since the environments differ, the code needed some adjustments for Netlify.

In order for our Edge proxy function to send analytics events to Pirsch securely, we need to generate an access key via the Pirsch dashboard. Navigate to the Integration Settings page of your Pirsch dashboard and click Add Client to create a new client. Set the type to ‘Access Key’. Give it a memorable name and click Create Client. Copy the access key and save it for later as it will not be visible again. We will configure it in Netlify as secure environment variable later.

Refactoring with Cursor

Instead of rewriting the logic manually, I used Cursor. I provided the Cloudflare example and asked it to convert the code to a Netlify Edge Function.

Cursor handled the conversion perfectly, mapping the correct Netlify header names and adjusting the fetch logic. I also had it move the Pirsch identification code into an environment variable to keep the repository clean.

Here is a look at the core logic:

const dashboards = {
    "markus-haack.com": {
        accessKey: (typeof Netlify !== "undefined" && Netlify.env?.get)
            ? (Netlify.env.get("PIRSCH_CLIENT_EDGE") ?? "")
            : ""
    }
};

const scriptPath = "/assets/js/pa.js";
const pageViewPath = "/p/pv";
const eventPath = "/p/e";
const sessionPath = "/p/s";
const accessControlAllowOrigin = "*";

const pirschScriptURL = "https://api.pirsch.io/pa.js";
const pirschPageViewEndpoint = "https://api.pirsch.io/api/v1/hit";
const pirschEventEndpoint = "https://api.pirsch.io/api/v1/event";
const pirschSessionEndpoint = "https://api.pirsch.io/api/v1/session";

export default async (request) => {
    return await handleRequest(request);
}

async function handleRequest(request) {
    const path = new URL(request.url).pathname;
    let result;

    if (path === scriptPath) {
        result = await getScript(request, pirschScriptURL);
    } else if (path === pageViewPath) {
        result = await handlePageView(request);
    } else if (path === eventPath) {
        result = await handleEvent(request);
    } else if (path === sessionPath) {
        result = await handleSession(request);
    } else {
        result = new Response(null, { status: 404 });
    }

    const response = new Response(result.body, result);
    response.headers.set("Access-Control-Allow-Origin", accessControlAllowOrigin);
    response.headers.set("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
    response.headers.set("Access-Control-Allow-Headers", "Content-Type, Authorization");
    response.headers.set("Accept-CH", "Sec-CH-UA, Sec-CH-UA-Mobile, Sec-CH-UA-Platform, Sec-CH-UA-Platform-Version, Sec-CH-Width, Sec-CH-Viewport-Width");
    return response;
}

async function getScript(request, script) {
    return await fetch(script, {
        headers: { 'Cache-Control': 'public, max-age=3600' }
    });
}

async function handlePageView(request) {
    const response = await fetch(pirschPageViewEndpoint, {
        method: "POST",
        headers: { "Authorization": `Bearer ${getAccessKey(request)}` },
        body: JSON.stringify(getBody(request))
    });
    const body = JSON.stringify(getBody(request, getOptions(request)));
    getRollupViews(request).forEach(async accessKey => {
        await fetch(pirschPageViewEndpoint, {
            method: "POST",
            headers: { "Authorization": `Bearer ${accessKey}` },
            body
        });
    });
    return new Response(response.body, { status: response.status });
}

async function handleEvent(request) {
    const data = await getData(request);
    const response = await fetch(pirschEventEndpoint, {
        method: "POST",
        headers: { "Authorization": `Bearer ${getAccessKey(data, true)}` },
        body: JSON.stringify(data)
    });
    const {prefix, suffix} = getOptions(data, true);
    data.url = rewritePath(data.url, prefix, suffix);
    const body = JSON.stringify(data);
    getRollupViews(data, true).forEach(async accessKey => {
        await fetch(pirschEventEndpoint, {
            method: "POST",
            headers: { "Authorization": `Bearer ${accessKey}` },
            body
        });
    });
    return new Response(response.body, { status: response.status });
}

async function handleSession(request) {
    const body = JSON.stringify({
        ip: getClientIP(request),
        user_agent: request.headers.get("User-Agent"),
        sec_ch_ua: request.headers.get("Sec-CH-UA"),
        sec_ch_ua_mobile: request.headers.get("Sec-CH-UA-Mobile"),
        sec_ch_ua_platform: request.headers.get("Sec-CH-UA-Platform"),
        sec_ch_ua_platform_version: request.headers.get("Sec-CH-UA-Platform-Version"),
        sec_ch_width: request.headers.get("Sec-CH-Width"),
        sec_ch_viewport_width: request.headers.get("Sec-CH-Viewport-Width")
    });
    const response = await fetch(pirschSessionEndpoint, {
        method: "POST",
        headers: { "Authorization": `Bearer ${getAccessKey(request)}` },
        body
    });
    getRollupViews(request).forEach(async accessKey => {
        await fetch(pirschSessionEndpoint, {
            method: "POST",
            headers: { "Authorization": `Bearer ${accessKey}` },
            body
        });
    });
    return new Response(response.body, { status: response.status });
}

function getClientIP(request) {
    return request.headers.get("x-nf-client-connection-ip") || 
           request.headers.get("x-forwarded-for")?.split(',')[0]?.trim() || 
           null;
}

function getAccessKey(request, fromBody = false) {
    return getDashboardConfig(getHostname(request, fromBody))?.accessKey ?? "";
}

function getRollupViews(request, fromBody = false) {
    return getDashboardConfig(getHostname(request, fromBody))?.rollup ?? [];
}

function getDashboardConfig(hostname) {
    for (const d in dashboards) {
        if (d.replace(/^www\./, "") === hostname) return dashboards[d];
    }
    return null;
}

function getHostname(request, fromBody = false) {
    if (fromBody) return new URL(request.url).hostname.toLowerCase().trim().replace(/^www\./, "");
    const url = new URL(request.url);
    const urlParam = url.searchParams.get("url");
    if (urlParam) {
        try {
            return new URL(urlParam).hostname.toLowerCase().trim().replace(/^www\./, "");
        } catch (e) { }
    }
    return url.hostname.toLowerCase().trim().replace(/^www\./, "");
}

function getBody(request, options = {}) {
    const { prefix, suffix } = options;
    const url = new URL(request.url);
    return {
        url: rewritePath(url.searchParams.get("url"), prefix, suffix),
        code: url.searchParams.get("code"),
        ip: getClientIP(request),
        user_agent: request.headers.get("User-Agent"),
        accept_language: request.headers.get("Accept-Language"),
        sec_ch_ua: request.headers.get("Sec-CH-UA"),
        sec_ch_ua_mobile: request.headers.get("Sec-CH-UA-Mobile"),
        sec_ch_ua_platform: request.headers.get("Sec-CH-UA-Platform"),
        sec_ch_ua_platform_version: request.headers.get("Sec-CH-UA-Platform-Version"),
        sec_ch_width: request.headers.get("Sec-CH-Width"),
        sec_ch_viewport_width: request.headers.get("Sec-CH-Viewport-Width"),
        title: url.searchParams.get("t"),
        referrer: url.searchParams.get("ref"),
        screen_width: Number.parseInt(url.searchParams.get("w"), 10),
        screen_height: Number.parseInt(url.searchParams.get("h"), 10)
    };
}

async function getData(request, options = {}) {
    const { prefix, suffix } = options;
    const data = await request.json();
    data.url = rewritePath(data.url, prefix, suffix);
    data.ip = getClientIP(request);
    data.user_agent = request.headers.get("User-Agent");
    data.accept_language = request.headers.get("Accept-Language");
    data.sec_ch_ua = request.headers.get("Sec-CH-UA");
    data.sec_ch_ua_mobile = request.headers.get("Sec-CH-UA-Mobile");
    data.sec_ch_ua_platform = request.headers.get("Sec-CH-UA-Platform");
    data.sec_ch_ua_platform_version = request.headers.get("Sec-CH-UA-Platform-Version");
    data.sec_ch_width = request.headers.get("Sec-CH-Width");
    data.sec_ch_viewport_width = request.headers.get("Sec-CH-Viewport-Width");
    return data;
}

function getOptions(request, fromBody = false) {
    return getDashboardConfig(getHostname(request, fromBody))?.options ?? {};
}

function rewritePath(url, prefix = "", suffix = "") {
    const u = new URL(url);
    u.pathname = prefix + u.pathname + suffix;
    return u.toString();
}

export const config = {
    path: [scriptPath, pageViewPath, eventPath, sessionPath]
};

You can find the full implementation, includuing comments and description in my GitHub repo:
pirsch.js on GitHub

Depending on how the edge functions are stored in the project, they are either recognised automatically or must be declared separately in netlify.toml. In addition, you must map the function to one or more URL routes. This can be done automatically using function name matching, directly in the code, or via netlify.toml. I selected the code option via the config object export, mapping the four paths that we are interested in. See above.

In addition to path mapping for a URL route, there are other ways to link a function to a request, for example via HTTP headers.

Configuration & Setup

To get this running, you need to add the PIRSCH_CODE to your Netlify environment variables. You can find this under Site configuration > Environment variables. Just create a new entry with your code from the Pirsch dashboard. For more details, check the Netlify Docs.

Page Setup

Finally, embed the script in your site’s <head> is needed. You can use the script generated during the initial dashboard setup as a starting point. We need to adjust it slightly to ensure that the analytics events are sent to our proxy. This means we need to change or replace the hostname and add additional hints to the Pirsch Analytics script to indicate where to send the data, depending on the paths configured in our edge function.

The src attribute must point to the proxy path of the JavaScript file. If you are running the proxy on the main hostname of your website, the path must be relative. However, if you have chosen to bind the proxy to a subdomain, the src attribute must be an absolute URL. The same applies for the data-hit-endpoint, data-event-endpoint and data-session-endpoint attributes. For my website the script tag looks like the following:

<script defer
  src="/assets/js/pa.js"
  id="pirschjs"
  data-hit-endpoint="/p/pv"
  data-event-endpoint="/p/e"
  data-session-endpoint="/p/s">
</script>

Summary

Would moving to Pirsch.io be a good idea for my setup? How does it compare to Plausible in a real project? I suppose we’ll find out over the next few months. It’s definitely a more cost-effective option for my current level of traffic. pattern. The dashboard looks nice! as well. With the first data flowing in:

From a technical perspective, setting up the Netlify Edge Function proxy with the help of Cursor took just minutes. For now, I can see that the proxy solution is working pretty reliably.

My Home Assistant Setup 2025: Reolink, EVCC, and New Dashboards

2025-11-19T00:00:00Z

Another year has passed and 2025 is coming to an end. Since my 2024 update, our Home Assistant setup has continued to mature and there have been some notable additions and refinements worth sharing. This post outlines the changes, new devices and valuable insights gained over the past year.

Architecture

As always, here’s the updated architecture diagram to help visualize the entire setup:

The Foundation

The Odroid N2 continues its remarkable run as the backbone of our system. Five years in, and it remains rock-solid reliable. I’ve already thought about upgrading to a Home Assistant Green Box, but so far there’s no real reason to upgrade. Sometimes the best upgrade is no upgrade at all.

The same applies to our Ubiquiti network infrastructure, which remains unchanged with the Unifi UDM Pro](https://ui.com/eu/en/cloud-gateways/dream-machine)o handling all routing duties. While this may be excessive for a residential setup, the stability and range of features make me confident that the investment is worthwhile.

The core technologies powering our smart home:

Device / Solution	Usage
ZHA using SonOff ZigBee 3.0 USB dongle	This is the main ZigBee Hub with over 40 devices connected via ZHA.
Homematic CCU3	Still in place for some remaing r remaining sensors
Rademacher DuoFern	Continue to operate all the window blinds and shutters.
Ubiquiti UniFi	Our home network is operated by UniFi wired and wireless devices.
Reolink	New to the house: a Reolink camera surveillance system.
Tasmota & Shelly	A variety of Wi-Fi switches and sockets. The Shelly devices are permanently installed, whereas the Sonoff devices — primarily Wi-Fi sockets.
Keba P30	Our EV charging station.
Solaregde Inverter	We can harvest our own energy, free of charge, from the sun.

Electric Vehicle Charging

One significant change this year was replacing our Mercedes with a Polestar 4. The switch meant updating our Home Assistant integration from MercedesME to the Polestar integration. Both car integrations in Home Assistant are custom components. Unfortunately, however, the one for Mercedes was significantly better and more comprehensive in terms of the data provided. This is simply because Mercedes provides a public API for developers, while Polestar unfortunately does not. This means that developers have to try to reverse engineer it. Polestar definitely has some catching up to do here; other car manufacturers are much more advanced in this respect.

I should also mention our Keba P30 charging station, which I somehow forgot to document in previous posts despite having it for a while now. Combined with the Polestar integration, we now have complete visibility into our EV’s status and can automate charging based on electricity rates and solar availability.

For optimized charging with solar power, we use EVCC. I have already written an introduction and setup guide for EVCC and a guide to smart charging with AI control.

Cameras

Late 2024 brought another complete camera overhaul. After experimenting with Scrypted and HomeKit Secure Video throughout the year, I decided to replace all cameras with Reolink devices. The Hikvision and Tapo cameras were sold off, and the entire surveillance system was rebuilt from scratch.

The Reolink cameras offer several advantages: excellent native Home Assistant integration, local recording without any cloud dependency, and superior image quality also with poor lighting conditions. The setup now includes a mix of Reolink PoE cameras at critical locations and WiFi models for easier installation in hard-to-wire areas.

Wireless Devices

The ZigBee network grew significantly with approximately 15 new devices, primarily new sensors and a few additional smart sockets joined the fleet as well.

On the WiFi side, we expanded our Tasmota fleet with four additional sockets (Nous A1 & Eightree). Their compact design and pre-flashed Tasmota firmware continue to make them an easy choice for quick smart home additions.

We added more Shelly switches (mostly Gen 2 & 3) for power monitoring and control. These replaced old Homematic components and provide more detailed energy data.

Other hardware changes

In late 2024, a Brother printer was integrated into our Home Assistant smart home system. It replaced an HP Inkjet, which was great but died suddenly. The Home Assistant integration for the printer allows us to monitor ink levels, paper status, and printer availability directly from our dashboards.

Home Assistant

Integrations & Custom Components

The integration list has grown with a few notable changes:

Replaced MercedesME 2020 with the Polestar integration
Added Keba for the P30 charging station
Added EVCC add-on and the ha-evcc custom component
Switched to Reolink for all camera integrations
Added Brother Printer for printer monitoring
Added Apple TV for media control and HomeKit hub functionality

The full list remains extensive, covering everything from ZHA, Shelly, Tasmota, AdGuard Home to WLED, with HACS providing access to custom components.

Dashboards

I have made progress towards my goal of migrating from YAML to UI-based dashboards. All dashboards and automations are now managed via the UI. When working on the automations however I Still switch to YAML mode from time to time.

I also change the main theme; our dashboards now have a shiny ~~liquid~~ frosted glass look.

The main dashboard has also been significantly overhauled. The dashboard is now cleaner. It got a nice weather card, and many details are displayed based on conditions. Information only shows up when it is really important and needed. I’m also a big fan of the new dashboard headers introduced in HA 2025.3 and with the new theme almost all custom CSS & card-mod styles go removed.

Backup

Backing up to our Synology NAS using the native Home Assistant continues to work perfectly. However, the new backup capabilities and cloud-based backup options introduced in early 2025 mean that we now have many more backup options and better control over backups when performing Home Assistant or add-on updates. Automated weekly backups provide peace of mind, and the integration is so seamless that I rarely think about it anymore — exactly as it should be!

Summary & Outlook

This year’s updates were more evolutionary than revolutionary. The focus has been on incremental expansion, replacing aging devices with more reliable alternatives, and optimizing existing automations. The camera migration to Reolink was probably the most significant change, finally settling on a surveillance solution that checks all the boxes: local control, excellent quality, and no subscription fees.

Integrating EVCC with our Keba charging station opens up new possibilities for energy management and smart charging automation.

Looking Ahead to 2026

For 2026, I’m planning to explore the Matter protocol and compatible devices in Home Assistant. I already have a few dual-stack light bulbs (ZigBee and Matter) that I’m eager to experiment with. So far, there hasn’t been a compelling reason to introduce Matter into our smart home - ZigBee has proven to be exceptionally stable and reliable.

I also plan to further optimize our energy management automations, particularly around EV charging. The goal is to better align charging schedules with solar production and dynamic electricity pricing. We recently had a smart meter installed by our electricity grid provider, so now I just need to find a suitable variable-rate electricity tariff to take full advantage of it.

DA Meets Universal Editor: Transforming Edge Delivery Workflows

2025-11-11T00:00:00Z

This year, I once again had the honour of speaking at the adaptTo() 2025 conference in Berlin.

Together with my colleague Max Voos, I introduced a new authoring paradigm for AuthorBus (formerly Dark Alley aka. DA) in a session.

https://www.youtube.com/watch?v=i6dJVELaB_o&t=1s

We demonstrate how AuthorBus integrates with Universal Editor and Edge Delivery Services, providing attendees with insight into its technical architecture and underlying mechanics. The talk covered implementation requirements and best practices for adoption, showcasing this innovative approach to content authoring on DA. It enables content creators to transparently switch between free-form, document-based authoring and guided WYSIWYG authoring using Universal Editor.

Complete evcc Setup Guide: Step-by-Step Installation and Configuration

2025-07-18T00:00:00Z

In my previous post about evcc, I introduced you to this powerful open-source energy management system and explained why it’s essential for anyone with solar panels and an electric vehicle. Now it’s time to get our hands dirty with the actual setup and configuration process.

This guide will walk you through exactly how I configured evcc with our specific hardware setup: a SolarEdge inverter with BYD battery, Keba P30 charger, and Polestar vehicle. Even if you have different equipment, the principles and process remain the same - you’ll just need to adapt the specific templates and settings.

Let’s dive into the technical details and get your smart charging system up and running!

Installing the Home Assistant Add-On

As I mentioned in part 1, I chose the Home Assistant Add-On route for our setup. The installation process using the Home Assistant Add-On was straightforward:

Add the evcc repository to Home Assistant - you can do this via the button on the docs page or manually by adding https://github.com/evcc-io/hassio-addon to your Home Assistant add-on repositories
Install the add-on from the Add-on Store - once the repository is added, you’ll find evcc in your Add-on Store
Configure through the built-in assistant or manual YAML editing - evcc provides both options depending on your preference

The entire installation took just a few minutes, and I was ready to start configuring my specific hardware.

Configuring Our Smart Charging Setup

evcc is configured via a central file, evcc.yaml. For a new setup, it can be created either with the configuration assistant or manually. The configuration assistant guides you step by step through the configuration of the various devices (photovoltaic system, electricity meter, house battery, EV charger and electric car).

A template file is provided for manual configuration. This provides the basic structure, and you can add your own devices and vehicles. There is extensive documentation for individual solar inverters, electricity meters, energy tariffs and vehicles, including customisable examples.

If something does not work or you have problems with the configuration, evcc also offers a debug mode to check the configuration of the individual devices and correct it if necessary.

In addition, evcc can be integrated into Home Assistant with just a REST and an MQTT API, allowing it to be integrated almost anywhere.

Our Hardware Setup

As you could already read in my Going Green articles, our photovoltaic system features a SolarEdge inverter with a 10 kW BYD Battery. As EV Charger we have a Keba P30 c-series and currently we drive a Polestar. I will now provide an explanation of how to integrate these components into evcc and use them as examples.

The first configuration steps are the global site settings such as name and the existing loadpoints. A load point is the designation for your charging station, for example a garage or carport. evcc supports more complex setups such as apartment blocks with several charging points. In our case it is only one EV charger in the carport.

site:
  title: JaMa Villa
  meters:
    grid: my_grid
    pv:
      - my_pv
    battery:
      - my_battery

loadpoints:
  - title: Carport
    charger: my_charger
    vehicle: my_car

SolarEdge System Integration

The next step is to define the meters. These are the existing electricity meters for the different sources, but at least the solar inverter and electricity grid. Optionally, if a home battery is installed, it will be metered as well.

Our case the SolarEdge hybrid inverter with battery storage required three meter configurations:

meters:
  - name: my_grid
    type: template
    template: solaredge-hybrid
    usage: grid
    modbus: tcpip
    id: 1
    host: modbus-proxy
    port: 1502
    timeout: 10s
  - name: my_pv
    type: template
    template: solaredge-hybrid
    usage: pv
    modbus: tcpip
    id: 1
    host: modbus-proxy
    port: 1502
    timeout: 10s
  - name: my_battery
    type: template
    template: solaredge-hybrid
    usage: battery
    modbus: tcpip
    id: 1
    host: modbus-proxy
    port: 1502
    timeout: 10s

As you can see as host address I do not use the IP address of the inverter directly, but the host name of a “ModBus proxy”. This is necessary because the SolarEdge inverters only allow one client on the ModBus server. As I had already integrated the SolarEdge inverter directly into Home Assistant, I had to find another solution. A ModBus proxy makes it possible for multiple clients to access a ModBus server, even if this server did not originally support this. There are several options for a ModBus proxy, I use a separate Home Assistant AddOn, but evcc can also take over this task.

The configuration of other solar inverters, especially via ModBus, is very similar.

Once the meters are configured the configuration can be checked via the following command:

/app # evcc -c /homeassistant/evcc.yaml meter
[main  ] INFO 2025/07/05 17:07:51 using config file: /homeassistant/evcc.yaml
[db    ] INFO 2025/07/05 17:07:51 using sqlite database: /root/.evcc/evcc.db
my_pv
-----
Power: 1748W

my_battery
----------
Power:        -0W
Soc:          99%
Controllable: true

my_grid
-------
Power:          -818W
Energy:         23571.0kWh
Current L1..L3: -1.78A 0.817A -2.18A
Voltage L1..L3: 227V 228V 229V
Power L1..L3:   -358W 14W -479W

If you are, like me, running evcc via the Home Assistant AddOn you need to use Docker command to open a shell first, this is described here.

Keba P30 Charger Configuration

The next and most important device we need to configure is the charging station for our electric vehicle.

chargers:
  - name: my_charger
    type: template
    template: keba-modbus
    modbus: tcpip
    id: 255
    host: 192.168.1.111
    port: 502
    welcomecharge: true

Like the majority of chargers, our Keba P30 c-series Wallbox is also addressed via Modbus TCP. Integration is very simple, you just have to use the correct configuration template and specify the IP address. A sponsor token is always required for a Keba charging station, like for many other charger brands as well.

A special feature of our charger is the authorisation to unlock the car charging. This is valid for 1 minute after the charging station has been activated. If no charging is started during this time, it expires and you have to re-authorise yourself with an RFID card or app. evcc therefore starts a ‘welcome charge’ so that the wallbox is not blocked again after 1 minute.

Unlocking the EV charger can be automated very easily via Home Assistant, with that no RFID card or charger app is needed.

There is also a check command for the charger. In my case the output looks like this:

/app # evcc -c /homeassistant/evcc.yaml charger
[main  ] INFO 2025/07/05 17:10:23 using config file: /homeassistant/evcc.yaml
[db    ] INFO 2025/07/05 17:10:23 using sqlite database: /root/.evcc/evcc.db
Power:          0W
Energy:         8071.9kWh
Current L1..L3: 0A 0A 0A
Charge status:  B
Status reason:  unknown
Enabled:        false
Identifier:     AABBCCDD
Features:       [WelcomeCharge]

Polestar Integration

Most chargers do not have the capability to read the State of Charge (SoC) of the car. That’s why we also want our car to be integrated with evcc. The software can then communicate directly with the vehicle via the manufacturer’s cloud service. A car integration is not strictly necessary and guest cars can be charged as well. However, if you own several vehicles and want to allocate the charging sessions and costs to the respective vehicle, the configuration is required. It also allows you to setup charging plans.

The Polestar integration, similar to other cars as well, provides state of charge, charging status, and remaining range. This enables evcc to calculate optimal charging schedules and stop charging at predetermined levels.

The config looks like:

vehicles:
  - name: my_car
    type: template
    template: polestar
    user: abcd@gmail.com
    password: my_password
    title: Polestar
    capacity: 100
    identifiers:
      - AABBCCDD # RFID token ID

The capacity is important here as this can not be automatically detected. In some cases, depending on the car brand, there is also a range of advanced options for the vehicle.

Similarly to the above, the vehicle configuration can also be checked via the command line:

/app # evcc -c /homeassistant/evcc.yaml vehicle
[main  ] INFO 2025/07/05 17:23:39 using config file: /homeassistant/evcc.yaml
[db    ] INFO 2025/07/05 17:23:39 using sqlite database: /root/.evcc/evcc.db
Soc:           90%
Capacity:      100.0kWh
Charge status: A
Range:         553km
Odometer:      9999km
Finish time:   2025-07-05 17:24:00 +0200 CEST
Identifiers:   [AABBCCDD]

Energy Tariff Configuration

In contrast to other countries, dynamic electricity tariffs are not yet widespread in Germany. There is a lack of infrastructure here and our electricity meters are not yet suitable for this. I have already ordered a new meter from our grid operator, but it will probably be a few months before it is installed.

evcc supports dynamic electricity tariffs in various countries and from various providers. When combined with charging plans, evcc automatically schedules charging sessions during low-price periods while still prioritizing solar energy. But we have to live with a fixed electricity tariff for now. The configuration for this is super simple:

tariffs:
  currency: EUR
  grid:
    type: fixed
    price: 0.30 # EUR/kWh
  feedin:
    type: fixed
    price: 0.09 # EUR/kWh

It’s Alive! Let’s Charge

And that’s it. The complete configuration took about 30 minutes. I already had all the information for the respective devices available. I was able to copy most of it directly from Home Assistant.

Now it’s time to connect the vehicle to the EV Charger and start the first charging process. Ideally on a sunny day. If everything is configured correctly, evcc should now start correctly and in the user interface we should be able to see the power generation data, the consumption, the status of the house battery and, most importantly, the charging process of the vehicle.

evcc - car charging user interface

Cost Analysis and Savings

While it’s still early days, I’m already seeing the benefits:

Reduced Grid Consumption: In June & July we charged our car 13 times - 268,4 kWh so far with 71% solar power
Better Feed-in Utilization: Rather than selling excess solar power for 9 cents/kWh, we’re using it to avoid buying grid power at 30 cents/kWh
Optimized Battery Usage: The home battery provides backup during cloud cover, reducing charging interruptions

Questions about evcc setup

These are the top 5 questions I collected related to your own evcc setup:

1. Do I need the exact same hardware setup to follow this guide?

No of course not, evcc supports a wide range of equipment from different manufacturers. The configuration principles remain the same - you’ll just need to use the appropriate templates for your specific solar inverter, charger, and car. Check the evcc documentation for your hardware’s compatibility and templates.

2. What if my inverter only allows one ModBus connection?

There are a few solar inverters, like ours from Solaredge, which only support one ModBus connection. Use a ModBus proxy to allow multiple connections. You can either install a separate Home Assistant ModBus Proxy AddOn or use evcc’s built-in ModBus proxy functionality.

3. Is vehicle integration mandatory for evcc to work?

No, vehicle integration is optional. evcc works fine without connecting to your car’s cloud service. However, integrating your vehicle provides State of Charge monitoring, charging plans, cost allocation for multiple vehicles, and better optimization. Guest vehicles can still be charged without integration.

4. How long does the initial setup and configuration take?

About 30 minutes total once you have all device information ready. Installation via Home Assistant Add-on Store takes just a few minutes, configuration takes 20-30 minutes, and testing another 10-15 minutes. Preparation time varies depending on whether you need to research device specifications.

5. What are the real-world savings I can expect with evcc?

Based on early results: 71% of EV charging powered by solar energy, avoiding 30 cents/kWh grid power by using 9 cents/kWh solar instead. evcc users report 50-80% solar-powered charging in good conditions. Actual savings depend on your solar system size, local electricity rates, car driving patterns, and weather.

Summary: Your Smart Charging System Awaits

Setting up evcc turned out to be much easier than I expected. Excellent documentation and well-documented templates for devices and vehicles made the configuration process straightforward.

If you have the basic components - solar panels, an EV charger, and an electric vehicle - evcc can transform your charging experience from a simple plug-and-go to an intelligent, cost-optimized system that maximizes your renewable energy usage.

Ready to optimize your own EV charging? The evcc community is incredibly helpful, and the documentation is comprehensive. Whether you choose the Home Assistant add-on route like me or prefer a different installation method, you’ll have your smart charging system up and running in no time.

Introduction to evcc: Smart Solar EV Charging Made Simple

2025-07-05T00:00:00Z

Two weeks ago, I took the next step in optimizing our smart home energy setup by implementing evcc (Electric Vehicle Charging Controller). This post describes my journey and gives you a complete introduction to what evcc can do for your EV charging setup.

Are you the proud owner of an electric car? Do you charge it at home? Have you installed a photovoltaic system on your roof? If so, then this article is exactly what you’re looking for!

Look no further if you want to find the best and most cost-effective ways to charge your car with as much solar power as possible.

I’m becoming a big fan of evcc, and I’m happy to share my experiences with it so far. To avoid making this post too long, I will give an introduction to evcc and explain what it does and why you should care. In a second post, I’ll walk you through the complete setup and configuration process with real-world examples.

What is evcc and Why Should You Care?

evcc.io is an open-source energy management system specifically designed for electric vehicle charging optimization. Think of it as the brain that decides when, how fast, and with what energy source your EV should charge.

The core functionality of evcc revolves around surplus solar charging - using your excess photovoltaic energy to charge your electric car instead of feeding it back to the grid.

But it goes beyond simple solar charging, it also handles:

Intelligent load management based on current household consumption
Dynamic pricing integration to charge when electricity is cheapest
Charging planning to ensure your car is ready when you need it
Home Assistant integration for seamless automation

What sets evcc apart is its manufacturer-agnostic approach. evcc isn’t proprietary and works with all sorts of brands and devices. At the time of writing this post 106 EV charger brands, 28 car brands, 21 heat pumps & electric heaters, 71 solar inverter & storage systems and 82 energy meters are supported.

Yes, there are also other (commercial) solutions for smart electric car charging, for example from energy providers or EV charger manufacturers, but which solution covers such a broad set of devices and vehicles?

Where can you combine a Keba P30 EV charger, a SolarEdge solar inverter and a BYD battery storage system with a Polestar vehicle, all of which work together intelligently?

How does evcc Work

The basic functions of evcc are pretty simple. The software handles your electricity sources, like our photovoltaic system and the grid, the state of the home battery, and the charging status of your electric vehicle.

evcc controlling the energy flow

It uses all the data points to work out the best charge rate and time for your electric vehicle, based on how much solar power is being produced at the moment and the electricity tariff. The idea is to make sure you’ve got as much surplus energy as possible, while also keeping grid electricity costs as low as possible.

The software runs always on your local hardware. It is cloud-free, privacy-friendly and independent of any charging, solar or electric vehicles brands. It is an open-source development, and the entire codebase can be found on GitHub.

As they don’t receive any external funding from vendors, the developers have chosen a community-funding-based approach to maintain the software. To use some of the commercial EV charger devices, you will need a sponsoring token. See the sponsorship documentation for more details. If you are not yet sure whether evcc is right for you, don’t worry — you can also get a trial token and test whether all your hardware works together properly.

Understanding the Charging Modes

evcc offers three distinct charging modes, each serving different scenarios. In fact, there are four modes if we include “off”.

evcc charging modes

PV Mode (Solar Only)

This is my favorite mode, as it only charges when there is sufficient solar surplus. Charging begins when your PV system generates more energy than your household uses, and the power is constantly adjusted to minimise grid import and export.

Min+PV Mode

It offers the best of both worlds, starting to charge immediately at a minimum power level (typically 6A) and increasing the power when a solar surplus is available. This ensures that charging always occurs while maximising solar utilisation.

The beauty of evcc’s approach is the continuous power adjustment. Unlike simple on/off solar charging solutions, evcc adjusts the charging current in real time based on available surplus, ensuring that every watt counts.

You can also configure a minimum SOC for the car battery. If the current charging state is below this level, evcc will charge in fast mode until the minimum SOC is reached and than switch to solar surplus charging. This ensures that you have enough power the next time you need the car.

Fast Mode

Maximum power charging, regardless of solar production or electricity prices. This is the ‘I need to leave in an hour’ mode, which charges as quickly as possible using any available solar power and grid power if necessary.

Off Mode

Charging is completely disabled, even when a vehicle is connected. This mode can be useful for maintenance or when you want to prevent any charging.

Battery Support

If your photovoltaic installation includes a home battery, it can support EV charging.

On days when it is slightly cloudy and the clouds are moving quickly, there can be fluctuations in the electricity yield of the solar cells. In such cases, the battery backup is very advantageous as it can provide short-term power to bridge the gap when shade is cast over the cells. This means that charging the vehicle does not need to be interrupted so frequently. Of course you can adjust the home battery SOC levels according to your needs.

Installation Options: Which Route Should You Choose?

evcc offers several installation methods, each with its own advantages:

Linux/Raspberry Pi Native

Direct installation via APT repository offers the best performance and easiest troubleshooting. This is ideal if you have a dedicated Linux system or Raspberry Pi. In my opinion, this setup is more suitable for advanced users, as you need to ensure that the entire system is kept updated and patched, and that you back up your data yourself, etc.

Proxmox

If you already use Proxmox as a virtualisation platform, this is probably where you want to host evcc as well. The installation process is similar to that for a dedicated Linux server.

Docker Installation

Docker is perfect for NAS systems such as Synology, Unraid and QNAP, providing isolation and easy updates. However, this will require some experience with Docker. There are community guides dedicated to running an evcc Docker setup on Synology and QNAP NAS systems.

macOS

The setup on macOS is pretty easy, as evcc can be installed via Homebrew within minutes.

Windows

It is possible to run evcc on Windows, but the creators do not really recommend it as it is Linux software.

Home Assistant Add-On: My Choice

This is the route I chose as a Home Assistant user, and for good reason. Since our entire smart home runs on Home Assistant, having evcc as a native add-on was the obvious choice for me. It provides me with:

Seamless integration with existing Home Assistant entities
A single interface for managing all smart home devices
Unified configuration, logging and troubleshooting
No need for an additional mobile app

The installation process using the Home Assistant Add-On was straightforward - I’ll walk you through the complete process in my setup guide.

Why I Think evcc is Essential for Solar EV Owners

After two weeks of using evcc, I can say it’s exactly what smart home technology should be: intelligent, automated, and genuinely useful.

It transforms our EV charging into a seamless process that optimizes for cost, environment, and convenience. For anyone with solar panels and an electric vehicle, evcc is not just recommended – if you ask me – it’s essential.

Here’s why I’m such a fan:

Universal Compatibility: Unlike proprietary solutions, evcc works with virtually any combination of equipment. You’re not locked into specific brands and can combine devices from different vendors.

Real Cost Savings: Instead of selling your excess solar power back to the grid for a few cents and then buying expensive grid electricity to charge your car, evcc helps you use your own renewable energy directly.

Privacy-Focused: The software runs always on your local hardware. It is cloud-free, privacy-friendly and independent of any charging, solar or electric vehicle brands.

What’s Next: Ready to Set It Up?

If you’re interested in implementing evcc for your setup, the next step is the actual installation and configuration. This involves configuring your specific solar inverter, EV charger, and vehicle - which can seem daunting but is actually quite straightforward with the right guidance.

In my next post “Complete evcc Setup Guide: Step-by-Step Installation and Configuration”, I’ll share the complete step-by-step setup process, including:

Detailed installation walkthrough for different methods
Real-world configuration examples with specific hardware
How to set up and test each component

The complete configuration took me about 30 minutes, and I already had all the information for the respective devices available from my Home Assistant setup.

Source Hero Image: Google AI Studio

Smart EV Charging: Automatic Home Charger Control with AI License Plate Recognition

2025-07-04T00:00:00Z

Are you familiar with the following situation?

You’ve just returned from shopping or work and the battery in your electric car is running low, so you need to charge it. You just need to plug the charging cable into the EV charger and switch charging on. But at the same time, you’ve still got groceries and other stuff in the trunk, and your hands are full. Ever found yourself fumbling for the RFID chip or card or opening the charger app just to start charging your electric vehicle?

We are actually regularly in exactly this situation. Our EV charger is openly accessible from the street. That’s why we have a model that can be locked so that nobody can charge their car without authorisation. Unlocking them isn’t usually a big deal, but sometimes it is when you have your hands full, have to carry something, etc.

What if your smart home could automatically recognize your car and start charging without any manual intervention? Today I’ll show you how I built an intelligent EV charging automation that uses camera motion detection and AI-powered license plate recognition to automatically unlock and start charging when our Polestar arrives home.

This leads us to two challenges:

Securing an EV Charger in an Open Carport

As our carport faces the street, our EV charger is visible and accessible to anyone walking by. Without proper access control, neighbours or strangers could easily plug in their vehicles and charge at our expense. Of course, we have cameras, but they won’t stop everyone. This is particularly problematic if we’re away from home for a while.

Freely accessible EV Charger

Fortunately, most modern smart home chargers address this issue by offering built-in authorisation options, often via RFID or an app. However, having to unlock them manually every time becomes tedious. This is where automation comes in, intelligently recognising authorised vehicles and automatically managing access control.

Detecting the car

The second challenge is recognising the vehicle and, above all, the right vehicle. We only want to activate the charger when our own vehicle is parked and not a other random vehicle.

You can try to recognise the car with the help of distance or motion sensors. At least whether an object, i.e. a vehicle, is in the carport or garage. But how do you know which vehicle it is?

There are a number of vehicle integrations in Home Assistant. There should be a way for almost every vehicle manufacturer to make the vehicle data visible in Home Assistant. Some of them, such as the BMW, Tesla or Mercedes integrations, can also provide GPS and location data. This is definitely a good way to recognise whether your own vehicle is in the carport.

As the Polestar integration can only provide very little vehicle data, I had to fall back on another option.

I used the cameras to recognise our car. The vehicle and the number plate are recognised via a snapshot which is analysed by AI. The automatic charging process is only started if the correct licence plate number is recognised.

Compatible EV Charger Requirements

This automation works with any smart EV home chargeer that supports authentication control and Home Assistant integration. Whether you have a KEBA - like our Keba P30, Wallbox, Ohme, Easee, Myenergi, go-e Charger, OpenWB, or other compatible charging station, the core principles remain the same.

If the charging station is installed in a garage or locked area, this is of course the easiest way. Since our carport is open and accessible to anyone passing by, we need a charger which can be locked and is only useable after authorization.

For this automation to work with your setup, your EV charger must integrated with Home Assistant and needs to meet these essential requirements:

Lock entity: For controlling authentication/access (lock.wallbox_authentication)
Binary sensors: For plug state and charging state monitoring
Reliable connectivity: Either local network or cloud-based control

Our Hardware Setup

The core setup consists of three components.

The EV charger

The heart of our setup is the KEBA P30 wallbox, which has excellent integration into Home Assistant. The KEBA integration provides binary sensors for charging state, plug state, energy counters, and crucially, a lock entity for authentication control and start/stop of the actually charging session.

Camera System

I’m using Reolink cameras and one of them is positioned in our carport to detect when a vehicle arrives. Our front door camera can also see the driveway. The cameras support generic motion detection, as well as person and vehicle detection, and snapshot functionality, all of which are accessible through Home Assistant. The vehicle detection binary sensors serve as our automation triggers.

AI Integration for License Plate Detection

As the camera itself can recognise vehicles as well as people or animals, we use it to take a snapshot photo. We now need image recognition to analyse the photo and recognise the number plate. For this we use an AI integration from Home Assistant.

I use the Google Generative AI for license plate recognition from camera snapshots. This eliminates the need for complex local computer vision setups while providing reliable plate detection and vehicle identification. Other AI integration such as OpenAI or Anthropic Conversation should also work here. If you don’t want to send your photos to the cloud, you can also use a local LLM (Large Language Model) via Ollama with a little more effort and computing power.

For more information about Home Assistant and AI integration topics see this blog post.

Setting Up the Prerequisites

Before implementing this automation, ensure you have these integrations configured:

EV Charger Integration

The configuration varies depending on the brand of EV charger:

For a KEBA charger, such as the one we have, the configuration is pretty simple. You only need to provide the charger’s hostname or IP address in your network and the RFID tag key used for authorisation.

For other common brands, this will be slightly different. Commonly used chargers (according to Google) are:

Wallbox brand chargers: use the built-in Home Assistant integration
go-e Charger: install the community integration via HACS
Tesla Wall Connector: use the built-in Home Assistant integration
ChargePoint: install the community integration via HACS
Zaptec: install the community integration via HACS
OpenWB: set up MQTT integration and configure the OpenWB MQTT topics

Camera Integration

Make sure your cameras are properly integrated into Home Assistant, that they expose motion detection binary sensors, and that they can take snapshot photos. While I recommend Reolink cameras, a wide range of other brands can be integrated with Home Assistant.

Reolink Camera with vehicle detection

Ideally, the camera will already have built-in object and person detection, which is also exposed to Home Assistant. This can be used instead of generic motion detection. This means that the automation will only be triggered when a vehicle is detected, rather than with every movement. If only a cat crosses the path and no vehicle is detected, the automation does not need to be started. If this is not available as a binary sensor, a generic motion sensor will suffice. However, this often leads to images being sent to the AI for analysis even when there are no cars.

Google Generative AI Integration

Set up the AI integration for image analysis capabilities. In case of Google Generative AI you’ll need an API key from Google AI Studio. For others the setup process is mostly similar.

Lets make it Smart

The automation follows a sophisticated workflow that balances security with convenience:

EV Charging Flow

Motion Detection: Camera sensors detect movement in the carport area via two different cameras
Condition Checks: Verify if the is already charging?
Patience Delay: 5-minute wait to allow parking and cable connection
Condition Checks: Verify the car is plugged in, the EV charger is locked, and not already charging
AI Analysis: Capture and analyze a snapshot to identify the license plate
Smart Decision: Unlock and start charging for authorized vehicles, or send alerts for unknown cars

The Complete Automation

This is how my automation looks like with the KEBA P30 charger and the Reolink cameras:

The complete EV Charging Automation

Here is the YAML version so that you can better adopt and customise it:

alias: Automatic Car Charging
triggers:
  - type: turned_on
    device_id: a8715.....................6f44e2
    entity_id: 41585.....................7f54bc
    domain: binary_sensor
    trigger: device
  - type: turned_on
    device_id: 3d634.....................76e7e4
    entity_id: e2dc6.....................5ede79
    domain: binary_sensor
    trigger: device
conditions:
  - condition: state
    entity_id: binary_sensor.keba_p30_charging_state
    state: "off"
actions:
  - delay:
      hours: 0
      minutes: 5
      seconds: 0
      milliseconds: 0
  - if:
      - condition: state
        entity_id: binary_sensor.keba_p30_charging_state
        state: "off"
      - condition: state
        entity_id: binary_sensor.keba_p30_plug
        state: "on"
      - condition: state
        entity_id: lock.keba_p30_authentication
        state: locked
    then:
      - action: ai_task.generate_data
        metadata: {}
        data:
          task_name: Analyse Parked Car
          instructions: >-
            Detect if a car enters the carport. Capture the license plate of the
            car and the car color.


            The camara taking the picture is place inside the carport below the
            roof. Only focus on cars directly inside the carport itself. The car
            must clearly entering the drive-in or be already inside the carport.


            Ignore:

            * Ignore cars just driving by.

            * Ignore cars on the other side of the street

            * Ignore cars in the neighbours garage or carport which is located
            on the opposite side of the street

            * Ignore the car directly next to the yellow house on the other side
            of the street.

            * Ignore cars in the background
          attachments:
            media_content_id: media-source://camera/camera.carport_fluent
            media_content_type: application/vnd.apple.mpegurl
            metadata:
              title: Carport
              thumbnail: /api/camera_proxy/camera.carport_fluent
              media_class: video
              children_media_class: null
              navigateIds:
                - {}
                - media_content_type: app
                  media_content_id: media-source://camera
          entity_id: ai_task.google_ai_task
          structure:
            license_plate:
              description: The license plate of the car
              required: true
              selector:
                text: null
            color:
              description: The color of the car
              selector:
                text: null
        response_variable: ai
      - if:
          - condition: template
            value_template: >-
              false
        then:
          - action: notify.mobile_app_iphone_von_markus
            metadata: {}
            data:
              title: JaMa Villa - 🚗
              message: >-
                Car is in garage, start charging automatically.
          - action: lock.unlock
            metadata: {}
            data: {}
            target:
              entity_id: lock.keba_p30_authentication
        else:
          - action: notify.mobile_app_iphone_von_markus
            metadata: {}
            data:
              message: >-
                A car was detected, but not sure this is ours. Better check.
              title: JaMa Villa - 🚗
mode: single

Make it your own

Even if it is not a blueprint, the automation can be adapted relatively easily. The following changes are necessary for this:

Device and Entity IDs
Replace all device IDs and entity IDs with those from your specific setup. Use Developer Tools → States to find the correct entities for your cameras and charger.
Licence plate check:
Assuming your licence plate is different to ours 😃, you need to change the check in line XX as well.
Unlock the charger:
Depending on how Home Assistant integrates with the EV charger, this might involve unlocking a lock, as in our case, or sending a command via MQTT or triggering a service to authorise and start charging.
Notification:
Replace the notification service and adapt the messages as required.

Licence plate recognition may require 2-3 attempts and some trial and error. AI recognition was not 100% accurate in our case, so I configured three options. False positive detection might be possible. If the Home Assistant integration for your vehicle provides location data, I would also use this for an additional check and incorporate it into the automation.

Conclusion and Future Enhancements

The current automation works very well for us. I’m very happy with it as it makes starting the charging process really easy!

However, as a Home Assistant Pro, you’re always thinking about how you can optimise things even further 😉. I also have the following ideas:

Multiple Vehicle Support: this is not an issue for us as we only have one car, but it certainly is for others.
Smart surplus charging via the PV system, which will definitely be an option for us.
Integrate with Home Assistant presence detection to disable the automation when residents are away, adding an extra security layer.

This smart EV charging automation is a really versatile solution. It’s got camera motion detection, AI image analysis and a connected EV charger, all controlled by Home Assistant. This means it’s really convenient and secure, as it automatically starts charging the cars you know about while blocking others. The logic works with various EV charger brands and camera setups, just needing a few minor tweaks for your specific hardware.

We’ve successfully used this automation with our KEBA P30 and Polestar over the last two weeks. Its key strength lies in Home Assistant’s ability to integrate diverse technologies – from simple sensors to advanced AI – into a practical automation that genuinely enhances daily life, regardless of your chosen EV charger.

Happy automating, and enjoy the convenience of never having to fumble for charging authentication again – no matter which EV charger or car you choose!

Image sources:

Hero: Michael Marais
Charger with car: Zaptec

Make Your Reolink Camera Speak with Home Assistant TTS & AI

2025-05-04T00:00:00Z

Ever wish your security camera could actually speak? Let’s talk about camera alerts and how we can make them even smarter. You’ve got your smart home cameras connected to the Home Assistant, and you get notifications whenever there’s motion. In my article Automate Reolink camera notifications, I explained how you can automate the camera notifications. That’s useful, sure. But a generic “person/car/animal detected” alert often leaves you pulling out your phone, opening the app, and waiting for the live feed to figure out what’s actually going on. More often than not, it’s just the cat from next door or the postman doing his rounds.

I wanted something smarter. I wanted Home Assistant to not just tell me that something happened, but what happened. Turns out with a little help from AI my smart home actually understand the camera feed.

The idea for this little automation is simple: when motion is detected, take a quick picture (or multiple), send that picture to an AI for analysis, and then have Home Assistant tell you the AI’s description out loud.

This guide will show you how to leverage Home Assistant with AI image analysis and Text-to-Speech (TTS) capabilities to get voice alerts and messages directly from your camera. But don’t worry if you’re using a different brand. The core method – camera event -> triggered snapshot -> AI analysis -> spoken alert via TTS – works with any camera integrated into Home Assistant that supports taking snapshots.

Here’s what you’ll need:

A Camera: Integrated into Home Assistant and capable of taking snapshots. I’m using Reolink, but the steps for the automation part are generic.
A Speaker/Media Player: Also integrated into Home Assistant (like a Sonos, Google Home/Nest speaker, etc.) to play the audio message.
A Text-to-speech integration: I use Home Assistant Cloud TTS for this.
Google Generative AI Access: You’ll need an Google AI Studio account and an API key for Gemini. We’ll cover how to get the integration set up.

You can also build this automation flow with other AI conversation integrations like Anthropic Conversation or OpenAI Conversation. I used Google AI Studio because it has a decent free tier with enough tokens for testing.

Ready? Let’s dive in.

Step 1: Get the Google Generative AI Integration Hooked Up

First things first, Home Assistant needs a way to talk to Google’s AI. There’s an official integration for this.

Go to Settings -> Devices & Services.
Click + Add Integration.
Search for “Google Generative AI Conversation” and select it.
It will ask for your API key. You’ll need to get one from Google AI Studio (it’s free for basic use). Just follow the link provided in the integration setup or search for “Google AI Studio API key”. It’s pretty quick to generate.
Paste your API key into the configuration and submit.

Screenshot 1: Google Generative AI Conversation integration

Once added, you’ll have a new service available in Home Assistant:
google_generative_ai_conversation. generate_content. This is what we’ll use in the automation.

Step 2: Ensure Your AI Conversation Integration is Ready

You can test the AI conversation agent via the Developer Tool > Actions page.

Screenshot 2: Testing the Google Generative AI conversation agent

Search the Google Generative AI: Generate content integration as shown in the screenshot and fill in the form with some test questions. Then click Perform Action.

Step 3: Set up Text-to-Speech (TTS)

The automation uses the Text-to-Speech feature to speak the response text from the AI’s analysis. I’m using the Home Assistant Cloud TTS in the example, but any configured TTS service like # Microsoft Text-to-Speech or Google Translate text-to-speech will work as well.

Make sure you have a TTS integration set up and a media_player entity ready to receive the audio. If you’re using Home Assistant Cloud, the tts.home_assistant_cloud entity should be available by default if you have Nabu Casa subscribed.

Similar like above, you can test it via the Developer Tool > Actions page.

Screenshot 3: Testing the Text-to-speech

Locate Text-to-speech (TTS): Speak like in the screenshot and fill out the form. You can also select your preferred language and voice.

Step 4: Build the Automation

Now for the fun part: putting it all together in an automation. We’ll mostly use the UI editor, which is generally the easiest way to get started. For one step, we also need to switch to YAML.

Go to Settings -> Automations & Scenes -> Automations.
Click + Create Automation and then Start with an empty automation.

Configuration:

Give it a clear name, like “Camera Motion - AI Analysis”.

Trigger

Click + Add Trigger.
Select Device.
Choose your camera from the list of devices.
Note: This part is specific to how your camera integrates. If your camera doesn’t expose a motion binary sensor directly as a device trigger, you might need to use an Entity trigger monitoring the motion sensor’s state change. For my Reolink camera in this example, a Device trigger works.
The Entity field should automatically show related entities. Select the motion binary sensor for your camera (it might be named something like binary_sensor.YOUR_CAMERA_NAME_motion).
The Type should be motion (see YAML below). This should be set automatically when using the visual editor.

Screenshot 4: Camera triggering the action

Conditions

We won’t add any conditions for a basic example. Click + Add Condition if you want to refine when this automation runs (e.g., only during the day).

In my example, I use a condition to run the automation only when we are at home using a simple stage condition.

Actions

Here’s where the magic sequence happens. Click + Add Action multiple times to add these steps:

Action 1: Take a Snapshot

Browse to and select the Camera: Take Snapshot service (aka camera.snapshot).
For Target, select the camera entity (camera.YOUR_CAMERA_NAME) that you want to take a snapshot of.
For Filename, you need to specify where you want to save the image. A good place is the /media folder, which Home Assistant uses by default for recordings and snapshots. Set the filename to something like /media/camera/frontdoor_snapshot.jpg. You can change frontdoor_snapshot.jpg to whatever makes sense, but remember that the /media/ path is important. Home Assistant needs permission to write here, which it usually has for this path.

Tip: You can take one or more snapshots. Gemini AI can also process more images and give you a more accurate answer. However, this will require more tokens and cost more money, depending on your conversation integration and AI subscription.

Action 2: Add a Delay

Click + Add Action again.
Select Delay.
Set a short delay, maybe 5 seconds. This gives Home Assistant time to actually write the snapshot file to disk before the next step tries to read it. It might not always be necessary, but it helps prevent errors.

Action 3: Send to Gemini AI

Click + Add Action again.
Locate and select the Google Generative AI ‘Generate content’ service.
This service takes a prompt and can analyze camera snapshots.
Enter the prompt: This is where you tell the AI what to do. The example YAML below has a specific, funny prompt that asks it to act like a “grumpy security officer” and answer in German. If you use this prompt, the AI’s response will be in English.
You can copy this, or write your own prompt in English (or any other language Gemini supports) if you prefer a different output. Make it specific about what you expect, ask it to briefly describe what it sees, ignore stationary objects/cars/buildings, etc.
Add a camera snapshot filename. Check Attachment filenames and enter the filename of the camera snapshot image. Make sure the filename matches the one in your snapshot action, like /media/camera/frontdoor_snapshot.jpg.
If you are taking multiple snapshots from your camera, make sure you add all the filenames.
It is important to add a field for the response variable. This is the name of a variable that will store the AI’s response for use in later actions. The example uses response.

Action 4: Speak the Result

Click + Add Action again.
Browse to your TTS service and select it. If you’re using Home Assistant Cloud, it’s tts.home_assistant_cloud.
For Target, select the media_player entity (your speaker) where you want to play the message.
In the message file, enter or copy the following template {{ response.text }}.

This will cause Home Assistant to switch to the YAML-based editor, as templates are not supported in the visual editor.
Your YAML should have at least three configurations: the speaker entity, the text-to-speech action and the message with the template.

Save:

Once all actions are added, click Save in the bottom right.

If set up correctly the automation steps should look like this:

Screenshot 5: Action flow of the automation

The Complete YAML

If you prefer to work with YAML, or just want to see how the whole thing is structured, here’s my automation code. If you build yours following the steps above, it should look similar. Feel free to copy it:

alias: Front door motion detection with AI description
description: ''
triggers:
 - type: motion
   device_id: <camera devide id>
   entity_id: <camera motion sensor entity id>
   domain: binary_sensor
   trigger: device
conditions:
 - condition: state
   entity_id: group.family
   state: Home
actions:
 - action: camera.snapshot
   metadata: {}
   data:
    filename: /media/camera/frontdoor_snapshot.jpg
   target:
    entity_id:
     - <camera entity id>
 - delay:
    hours: 0
    minutes: 0
    seconds: 5
    milliseconds: 0
 - action: google_generative_ai_conversation.generate_content
   metadata: {}
   data:
    prompt: >-
     You are a grumpy security officed whatching surveillance cameras all day
     long. Briefly describe what you see in this image from my frontdoor
     camera. Don't describe stationary objects, cars or buildings. Answer
     always in German.
    filenames:
     - /media/camera/frontdoor_snapshot.jpg
   response_variable: response
 - action: tts.speak
   metadata: {}
   data:
    cache: true
    media_player_entity_id: media_player.move
    message: ''
   target:
    entity_id: tts.home_assistant_cloud
mode: single

If you copy the example below, be sure to change the placeholders. You can find these in the Automation Editor when setting up the trigger/actions, or by looking at the entity and device details in Settings -> Devices & Services -> Entities or Devices. Also adjust the trigger definition if your specific camera integration requires a different method of detecting motion (e.g. an entity state change).

Once copied, you can also switch to the Visual Automation Editor and change the parameters in the interface.

Save the automation and try triggering motion on your camera. With a bit of luck (and correct paths/entity IDs), you should:

Get motion detected in Home Assistant.
See a snapshot file appear in your /media/camera folder. You can check the stored snapshots using the Home Assistant Media Browser.
After a few seconds, hear your speaker announce (the language will depend on your prompt!) what the AI saw in the picture, hopefully ignoring boring stuff like the wall or a parked car.

If it doesn’t work, check the automation trace logs and the Home Assistant logs (Settings -> System -> Logs) for errors related to automation, camera snapshot, Gemini service call or TTS service call. Check your Entity IDs, the snapshot filename path and your Gemini API key.

You can also play around with the Gemini prompt to get different types of descriptions or different languages. The grumpy security officer in German is just a fun idea - try writing a prompt in English for an English response.

Conclusion

So there you have it! We’ve taken a basic camera motion alert and elevated it into a more intelligent system. Instead of just knowing that there’s motion, Home Assistant now takes a peek, asks an AI what it sees, and tells you the relevant details.

This setup, using a snapshot and an AI conversation service, isn’t limited to Reolink or even just Gemini. The concept works with any camera that can take snapshots via Home Assistant and with other AI conversation integrations you might have configured.

And honestly, integrating an AI conversation model like Gemini opens up a ton of possibilities beyond just camera analysis. You can use it to make other notifications smarter, get summaries of events, or even potentially use it as part of voice control flows. This little project just scratches the surface.

It’s always satisfying when you can make your smart home a little bit smarter and more proactive. Getting a spoken description of what’s happening outside, without having to check my phone, feels like a genuine upgrade.

Let me know if you build this or if you’ve found other cool ways to leverage AI in your Home Assistant setup!

Weather Cards in Home Assistant: My Top Picks

2025-04-22T00:00:00Z

Whether you want to see if you need an umbrella, trigger garden automation, or just want a nice weather forecast, it’s easy to integrate weather data into your Home Assistant. I don’t think I need to explain why having weather information on your Home Assistant dashboard is helpful. Almost every Home Assistant user has a weather card on the dashboard.

But there’s a bit more to it than just connecting a weather integration - you also need a suitable weather card. Many people have one on their home dashboard. It is one of the first cards you see when you open Home Assistant in your app or browser. So you want a nice, clean weather card that shows you all the information you need.

Over the past few weeks, I’ve been experimenting with different weather cards for my own dashboard. In this article, I’ll take you through the options I’ve tested, how to set them up, and the differences I’ve noticed in everyday use. By the end, you’ll know which approach works best for you - without having to install and remove five different cards yourself.

Why Upgrade From the Default?

During my search for a better solution, I tested a handful of community cards that promise more features or a fancier look. Below are the four I’d recommend checking out, in order of increasing complexity and customization.

The setup

You don’t need much to get started with a simple weather card. In fact, all you need is a configured weather integration. I use the default Open-Meteo integration which provides all the weather details and forecasts I need. Other weather data provides will of course work as well.

For more advanced uses, additional integrations such as UV data or a local temperature and pressure sensors will be helpful.

Almost all of the custom weather charts listed below offer powerful configuration options. In this article I can only summarise the highlights. A detailed list of all available options can be found in the linked GitHub repositories.

1. Official Home Assistant Weather Forecast Card

Home Assistant includes a simple built-in weather forecast card. Adding it to your dashboard is quick and works with most integrations out-of-the-box.

This is the default option under Add Card > Weather Forecast in the dashboard editor. Setup is as simple as picking your weather entity.

Screenshot 1: Home Assistant Weather Card

It shows current conditions and a five-day forecast in a compact design that fits anywhere. You can switch between hourly and daily forecasts. You can select the number of forecast entries. You can choose an extra value to display below the main temperature - humidity, rainfall or wind. For many users, this may be enough.

Setup:
Just add it from the Lovelace UI. No YAML or HACS install needed.

When to use:
If you want something reliable and straightforward without any extra dependencies.

2. Clock Weather Card

While testing different weather cards, I also came across the Clock Weather Card. This option combines a digital or analogue clock with weather information, making it particularly useful for dashboards on wall tablets or displays where you want to see both the time and current conditions at a glance. Ideal for your home screen dashboard.

Screenshot 2: Clock Weather Card

Installation:
Like most custom cards, the Clock Weather Card can be installed via HACS. Just search for “Clock Weather Card” in the HACS Frontend section and install it. After that, use the Lovelace UI to add it as a custom card.

Features:
You get a clear display of the current time alongside the weather icon, temperature and optional short forecast. The card is very powerful and already adds some complexity. There are several style options, including analogue and digital clocks, time zone and format, different animated icons, and you can customise which weather unit it uses. Various elements (current conditions, time & date, forecast) can be hidden for a very personal style. The number of forecast days is also configurable. The card also supports additional sensors for local temperature, humidity, apparent temperature and air quality. It also supports full localisation for a large list of languages.
With a wide range of compatibility with different Lovelace themes, making it easy to fit into your overall dashboard look.

Configuration:
The Clock Weater Card currently only supports YAML configuration. A UI configuration mode is not yet available.

My impression:
The card is perfect if you want a simple, nice to look at info panel that shows both the time and weather. I find it works best in the mobile app dashboard and on always-on displays in the kitchen or hallway, as guests instantly see both the weather and what time it is. It doesn’t have as many advanced options or data points as the Platinum Weather Card, but it handles the basics very elegantly.

3. Platinum Weather Card

If you like to tweak every pixel or combine weather data from multiple integrations, Platinum Weather Card is the tool for you. This is your power horse for weather data. It’s designed as a flexible, fully GUI configurable weather card - no YAML needed if you don’t want to. Like the other cards before it shows the current weather conditions and the forecast. But it does not stop there, it can display various details such as

sunrise and sunset
wind conditions, speed and direction
recorded rainfall
visibility
rain or snowfall forecast
UV forecast
fire danger

In the details section you can freely configure up to 16 attributes (2 columns of 8 each).

The forecast section of the cards supports two different layouts: horizontal and vertical. While the horizontal view displays icons and values in a row similar to the other cards, the vertical view is very verbose and gives you a detailed view of the coming days. This includes weather conditions, forecast temperature and rain, and a written weather forecast.

Installation:
Install via HACS under Frontend. Search for “Platinum Weather Card” and install. Then, add a new card of type Custom: Platinum Weather Card to your dashboard.

Configuration:
The card is fully configurable via the UI. It opens a full GUI editor with tons of settings. You can choose which data sources to use for each field, change the icon set, customise the forecast layout and much more.
To take advantage of the full feature set of this card, you will need multiple sensors. The default weather sensor may not be sufficient for this card. You will also need UV (such as from OpenUV or tomorrow.io) and fire danger forecast. Local temperature sensors can also be used.

My impression:
This Weather Card is perfect for anyone who wants to get and display all the data they can. The card allows extensive configuration and can be flexibly customised. However, this card is too much for a simple daily weather display that you look at on a tablet on the wall as you pass by. It is almost better suited for a seprated weather dashboard with a lot of details.

4. Simple Weather Card

This is the opposite of the previous weather card. If you prefer a clean look and just the essentials, the Simple Weather Card is worth a try. This card is designed to minimise clutter while still providing the most important weather data. It’s great for smaller dashboards, side panels or mobile views where space is at a premium.

Screenshot 3: Simple Weather Card

Installation:
Same like before, you’ll find the Simple Weather Card in HACS under Frontend. After installing, just add it as a custom card through the Lovelace dashboard editor.

Features:
The minimalist layout of this weather card is straightforward - current weather icon and temperature, with options for additional details such as humidity, wind or precipitation. You can also customise which attributes are shown if you want to keep things extra minimal.

The card has a nice day and night view and you can customise the background color of the card.

It works with standard weather entities, so it’s compatible with the usual Home Assistant weather integrations. A local temperature sensor is also supported.

Configuration:
The Simple Weater Card currently only supports YAML configuration.

My impression:
I use the Simple Weather Card on my phone dashboard because it loads quickly and doesn’t overwhelm the screen. It’s also a good choice for secondary dashboard panels where I don’t need a detailed forecast, just a quick overview. If you have family members who get confused by too much detail, this card keeps things simple and usable.

Other options:

• Hourly Weather Card: A simple card to visualise upcoming weather conditions as a coloured horizontal bar. This card focuses on one thing and does it perfectly.

• Weather Chart Card: If you prefer graphical trends, this card visualises forecast data such as temperature and precipitation over time. Similar to the Platinum Weather card this card, with all the details, deserves more space on the dashbaord.

Which Card to Choose?

If you’re happy with a basic weather summary:
Stick with the built-in card. It’s low-maintenance, fast, and works everywhere.

For a visually appealing dashboard, especially on a wall tablet:
Try the Clock Weather Card, he animations are subtle but make a big difference. Or, if you prefer a more minimalist design, choose the Simple Weather Card.

If you want maximum control and like to experiment:
Platinum Weather Card is the most powerful option, letting you mix and match data sources and customize the look.

My Setup

At the moment I use the Clock Weather card in my main dashboard in combination with the forecast from the then standard built-in weather card. Using the custom `vertical-stack-in-card’ card, these can be nicely stitched together to give them a “one card” look and feel. Here is the YAML of the combination:

type: custom:vertical-stack-in-card
cards:
 - type: custom:clock-weather-card
   entity: weather.jama_villa
   temperature_sensor: sensor.garden_temperature
   locale: de
   weather_icon_type: fill
   hide_clock: true
   hide_date: true
   forecast_rows: 3
   show_decimal: true
   hide_forecast_section: true
 - show_current: false
   show_forecast: true
   type: weather-forecast
   entity: weather.jama_villa
   forecast_type: hourly
   forecast_slots: 6
 - type: custom:clock-weather-card
   entity: weather.jama_villa
   temperature_sensor: sensor.garden_temperature
   locale: de
   weather_icon_type: fill
   hide_clock: true
   hide_date: true
   forecast_rows: 3
   show_decimal: true
   hide_today_section: true

Screenshot 4: My Weather Card Combo

Conclusion

There’s no one-size-fits-all answer. Home Assistant’s default forecast card covers the basics well, but the community has provided excellent alternatives for anyone wanting more features or a nicer look.

If you haven’t tried a new card in a while, I recommend experimenting—weather is one of those bits of information you glance at every day, so it’s worth making it just right.

Happy automating!

Home Assistant Backup in 2025

2025-02-23T00:00:00Z

Two years ago, I wrote about backing up Home Assistant to a Synology NAS using NFS shares. While that method still works, the Home Assistant team has gone all-in on backups and massively improved Home Assistant’s native backup capabilities with the 2025.1 and 2025.2 releases. I have already adjusted my backup configuration. Let’s explore what’s new and why you should update your approach.

The Home Assistant team calls the now backup strategy: 3…2…1… Backup. This means a solid backup strategy follows the 3-2-1 rule:

3 copies of your data
2 stored on different media
1 kept off-site

The recommendation is to backup regular and frequently. IMHO once a week is a good rule of a thumb. Keep backups at different locations. If you house burns down or a lightning strike you local and NAS backup could be extinguished. To be prepared for this, I synchronise important data from our NAS to the cloud (AWS S3 in our case). With the new cloud backup destinations, this can now be done directly from Home Assistant.

Upgrade your backup strategy with Home Assistant’s 2025 features.

Let’s have a quick look at them together, and then I’ll give you step-by-step instructions on how to configure a backup from Home Assistant 2025 onwards.

Easy Setup
The Home Assistant team has spent a lot of time making the experience as simple as possible. A new automatic backup configuration can be created with just 3 clicks.
Cloud Storage
Automatic backups can be saved locally or off-machine. For Home Assistant subscribers, these can be stored directly in Home Assistant Cloud. Network shares will of course continue to work. Other cloud backup options include Google Drive and Microsoft OneDrive and there will be more (cloud) backup locations in the future.
Encryption
Backups to the Home Assistant Cloud are now secure and encrypted by default. For local backups to your NAS, you can choose to store them encrypted or unencrypted.
Scheduling and Retention
The new automatic backup also makes it easier to keep an overview. You can flexibly set when and how often the backup should run and how many versions should be kept.

Native backups to the place of your choice

Home Assistant 2025.2 eliminates the need for plugins such as Samba Backup or Google Drive add-ons. The update introduced native integrations for

Synology NAS via DSM
Google Drive
Microsoft OneDrive

The integrations for these have been updated and are ready for the new automatic backups. This gives Home Assistant users who are not subscribed to Home Assistant Cloud many alternative cloud storage or local storage options.

You can also combine locations for 3-2-1 protection – I store weekly backups on my Synology NAS and Home Assistant Cloud simultaneously. Here I keep the last 3 backups. Additionally I create a backup on every Home Assistant update, just in case.

From 0 to data protection in 90 seconds

Setting up the new automatic backup does not take much time.

Navigate to Settings → System → Backups
Click Set Up Backups
A new encryption key will be created the first time, please make a note of it. Store it in a password manager!
Click Next
Select Recommended Settings

Done - Home Assistant will create your first backup for you.

Screenshot 1: Home Assistant Backup

To save a backup of our system in the cloud, just a few clicks are necessary. In the Backup settings area, click on the last menu item for the backup locations.

Screenshot 2: Home Assistant Backup Locations

The local backup should already be displayed here. In my case, I have already moved this to the NAS as storage space. Cloud storage locations can now also be selected here for the backup.

Depending on your configuration, several backups will accumulate over time. Click ‘Show all backups’ to view all backups.

Screenshot 3: Home Assistant - My Backups

Which locations are displayed here depends on the installed integration Google Drive, Microsoft OneDrive and Synology DSM. And whether you have a Nabu Casa subscription or not. Only with Nabu Casa subscription you will have the “Home Assistant Cloud” option.

Backup to Synology in 2025

If you want to store your backup on a Synology NAS, please have a look at my first article. The configuration steps on the NAS are exactly the same and still apply.

In order to select Synology as a backup target for Home Assistant, an extra configuration step is required:

Go to Settings > Devices
Select the “Synology DSM” integration
Click on “Configure”
In the dialog select one of the shared folders and enter an folder name.

The shared folders are configured on the Synology NAS. If this list is empty or the desired folder for the backups does not appear here, this must be set on Synology. See my first article on how to achive this.

The dialog should look similar to:

Screenshot 4: Synology Backup Config

After the Synology backup directories have been configured, Synology DSM is made available as a backup location.

Go back to the backup settings and click configure again. Synology DSM is now available as backup location and can be enabled. You can select whether the backups on the NAS should be encrypted, see next chapter. I have switched this off in my case.

Screenshot 5: Synology Backup Location

The generic NAS backup localtion can still be used, but is not requiered any more.

Other integrations are not automatically configured as a backup target and must be set up separately. See the integration documentation for more information.

Flexible Encryption

Home Assistant 2025.1 introduced automatic encryption of all backups. While encryption is still the default, you can now disable it on a per location basis.

Why disable? Unencrypted local or NAS backups allow direct file recovery without Home Assistant. This can be useful in some cases. However, cloud backups will always remain encrypted for security.

Precision Scheduling & Smart Automation

Automatic backups allow a very flexible setting of when - day & time - a backup should be created. The retention period can also be set individually.

In my case, I have a backup created at the weekend, every Saturday at 4.45am. The days, frequency and even the backup time can be set to suit your needs. Retention can be configured based on the number of backups you want to keep or the number of days you want to keep them.

If the recommended settings to not fit go to: Settings → System → Backups and select the first option in the Backup settings area. This will bring you to the automatic backups options which can be flexibly adjusted here.

Screenshot 6: Home Assistant Automatic Backup Options

Conditional Backups via Automation

In addition to all the automatic backup settings, you also have the option of creating backups manually or using automation.

This makes sense, for example, if a fixed schedule cannot be used because, for example, the NAS server is switched off at night. Home Assistant provides the backup.create_automatic action for automations.

The following sample automation trigger backups when your NAS is awake:

automation:
 - alias: 'Backup Home Assistant 5 min after NAS is online'
   triggers:
    - trigger: state
      entity_id: binary_sensor.nas_online
      to: 'on'
      for:
       hours: 0
       minutes: 5
       seconds: 0
   actions:
    - alias: 'Create backup now'
      action: backup.create_automatic

With the help of a simple automation above, you can start the creation of a backup for a specific backup destination.

Disaster Recovery Protocol

Just as important as the regular creation of backups is the restoration. This should also be tested regularly.

This is somewhat more time-consuming and annoying to accomplish. Nobody wants to mess around with their production system. That’s why you need a second piece of hardware to test the restore procedure. I use a Raspberry Pi that I still have lying around. Here I test the restore flow using my backups stored on our NAS. Unfortunately, the whole thing is quite time-consuming and I admit I should actually test it more often. Fingers crossed the Home Assistant backups are ok and not defective.

Final Thoughts: Backups Are Boring Until They’re Critical

Let me summarise what has changed and improved compared to my first Home Assistant backup article in the following table.

Feature	2023 Approach	2025 Approach
Backup Locations	Local or NAS Additional only via Add-ons	Local, NAS & Cloud Backup built-in
Encryption	n/a	Per-Location Toggle, Mandatory for Cloud locations
Trigger	Via Automation	Auto-Triggered, Via UI, Via Automation

Home Assistant’s 2025 backup tools have matured. With all the new features and configuration options, there is no excuse for not backing up your system. It’s easier than ever before.

Define your backup strategy today – your future self will thank you when the SD card fails at 2 AM.

Our 2024 Solar Power Performance

2025-02-01T00:00:00Z

Our home’s solar energy system continued its upward trajectory in 2024. In fact, compared to previous years, it provided a slight increase in energy production. This post looks at our solar performance in 2024, highlighting key trends and comparing them with the results from 2021, 2022 and 2023.

2024: A Bountiful Harvest of Solar Energy

In 2024, our solar panels generated a total of 8571 kWh, an improvement on 2023 but slightly lower than 2022. This represents a step towards greater energy independence and, of course, a lower energy bill. As expected, the data clearly shows a seasonal pattern:

Peak Production (June & July): June and July were our most productive months with 1246 kWh and 1279 kWh respectively. This highlights the effectiveness of our system during peak sunlight hours. July & August 2024 had the highest energy yield compared to July & August of previous years. May was still good with a production of 1,140 kWh, but it looks like we had much less sun in May in 2024 compared to previous years.
Lowest Production (December & January): As expected, December (132 kWh) and January (181 kWh) had the lowest production due to shorter daylight hours and less intense solar radiation. However, both of these months were the best since our records began. In previous years, we did not even reach > 100 kWh in these winter months.

Last 4 Years of our Energy Production

The table below provides a comparison of our energy production and consumption across the years 2021-2024:

Year	Solar Energy Production	Electricity Consumption	Grid Electricity Used	Self-Consumption	Self-Consumption Quota
2021	7780 kWh	9721 kWh	4677 kWh	5044 kWh	52 %
2022	9104 kWh	10192 kWh	4552 kWh	5640 kWh	55 %
2023	8292 kWh	10361 kWh	5181 kWh	5180 kWh	50 %
2024	8571 kWh	10297 kWh	4994 kWh	5303 kWh	52 %

Energy Consumption: A Relatively Stable Baseline

Our total electricity consumption for 2024 was 10297 kWh, a relatively stable figure compared to recent years. The increase in solar energy production in 2024 compared to 2023 allowed us to self-consume 5303 kWh, reducing our reliance on the grid to just 4894 kWh. This reduced our grid dependency by ~100 kWh.
Unfortunately, due to rising electricity prices in Germany, this is not reflected in the electricity costs.

Outlook: Changes in sight - or not

The year 2024 was similar to previous years, both in terms of solar energy production and our consumption. There has been no major change. However, we have noticed a slight increase in electricity production compared to previous years, especially in the winter months, as we have less snow and frost. We can also observe this in January 2025.

Overall, we do not expect any fundamental changes in 2025. By changing the electricity provider, we will probably be able to further reduce the electricity costs for grid purchases. We may also switch to a dynamic electricity tariff later in the year.

Implement large-scale projects on AEM Edge Delivery Services

2024-11-02T00:00:00Z

We recently had the opportunity to present at adaptTo() in Berlin, one of the most anticipated tech conferences in the Adobe Experience Manager community. Together with my colleague Anian Weber we delivered an in-depth session on AEM Edge Delivery Services, focusing on how its capabilities have evolved well beyond small blog websites and basic corporate pages. Our talk aimed to answer a critical question: Is it feasible to implement complex, multilingual, and multisite projects using AEM Edge Delivery Services while preserving the performance, flexibility, and ease of use it promises?

Key Takeaways from Our Talk

Our presentation explored strategic approaches to designing and managing global, multilanguage projects within the AEM Edge Delivery framework. Based on real-world projects and challenges we’ve encountered, we walked attendees through essential steps in setting up large-scale projects, from effective developer configurations and content organization strategies to optimized translation workflows.

For those interested in diving deeper into these topics, our slide deck is available on the adaptTo() conference website. And stay tuned—the full recording of our talk will be available soon!

Final Thoughts

In addition to our presentation, I also had the pleasure of participating in an expert panel discussion on Adobe Edge Delivery Services. This session was a great chance to connect with AEM developers and learn about their thoughts & questions about the potential and challenges of Edge Delivery.

Presenting at adaptTo() Berlin was a fantastic experience, and I’m excited to see how AEM Edge Delivery Services continues to transform as a robust solution for complex, multilingual projects. Thank you to everyone who attended our session and engaged with us during the panel discussion!

For anyone interested in implementing AEM Edge Delivery for large-scale, global projects, feel free to reach out—we’re always excited to discuss insights and share knowledge on this evolving platform.

Automate Reolink camera notifications with Home Assistant

2024-09-19T00:00:00Z

As I wrote in my previous post, I recently switched from Arlo cameras to Reolink cameras. The Reolink cameras have excellent hardware quality, an aluminium housing and no cloud subscription obligation.

However, there are some gaps in the software and functions that have been standard with Arlo and other providers for years are missing here. The camera alarms cannot be automated and there is also no geo-fencing in the app so that the cameras can be activated automatically when everyone has left the house.

This is where Home Assistant comes into play, as it can close these gaps.

What is actually missing in the Reolink Software?

The only out-of-the-box way to quickly change the recording or push notification settings of multiple cameras at once is to use shortcuts within the Reolink app:

Scenes in the Reolink iOS App

At least in the Reolink iOS app, this feature is somewhat hidden and not immediately obvious. In the camera view, you normally only see the cameras. However, if you drag the whole view down a bit, you can see 3 badges. These are assigned shortcuts that can also be customised. You can toggle recording on and off, and enable or disable push or email alerts for each camera. You can also turn on the alarm sound.

You can create different scenes. What you cannot do is control these scenes automatically. You always have to open the app to activate them, and they cannot be triggered at a certain time or by another event.

So how do we solve this problem? To fill the gaps and add the missing functionality, Home Assistant comes in as a powerful smart home platform.

Automate the push notifications

Just like us, almost all camera users only want to receive push notifications at certain times. We have different notification profiles depending on the time of day or day of the week.

When we’re at home in the garden, we don’t need notifications from the cameras in the garden or by the pool. It’s only us who would trigger them anyway. However, if someone is at the entrance and rings the doorbell, we don’t notice this in the garden, so notifications from the entrance camera are important.

In our case the notifications will follow this patten:

Camera	Week - Day	Weekend - Day	Nights
Frontdoor	on	on	on
Carport	on	off	on
Garden	off	off	on

To enable / disable the notifications as needed I use two automations in Home Assistant. The first on is triggered at sunset to enable the push notification settings of all the cameras:

In YAML this looks like (simplified version):

alias: '[Camera] Activate notifications on sunset'
trigger:
 - platform: sun
   event: sunset
   offset: 0
condition: []
action:
 - type: turn_on
   device_id: <<< camera 1 >>>
   entity_id: switch.<<< camera 1 >>>_push_notifications
   domain: switch
 - type: turn_on
   device_id: <<< camera 2 >>>
   entity_id: switch.<<< camera 2 >>>_push_notifications
   domain: switch
mode: single

The second time-based automation is triggered at sunrise in the morning to switch the notifications back on. This only runs when we are at home, as we do not want the push notifications to be turned off when we are away. The carport camera notifications are only disabled at weekends.

In YAML this looks like:

alias: "[Camera] De-activate notifications on sunrise"
trigger:
  - platform: sun
    event: sunrise
    offset: 0
condition:
  - condition: state
    entity_id: group.jama
    state: home
action:
  - type: turn_off
    device_id: <<< camera 1 >>>
    entity_id: switch.<<< camera 1 >>>_push_notifications
    domain: switch
  - type: turn_off
    device_id: <<< camera 2 >>>
    entity_id: switch.<<< camera 2 >>>_push_notifications
    domain: switch
  - if:
      - condition: state
        entity_id: binary_sensor.workday_sensor
        state: "off"
    then:
      - type: turn_off
	    device_id: <<< camera 3 >>>
	    entity_id: switch.<<< camera 3 >>>_push_notifications
        domain: switch
mode: single

Add the missing geofencing

When we are out and about and nobody is at home, we naturally also want to be notified by the cameras if something happens. Why else would we have surveillance cameras?

As it is not possible to control these automatically via the Reolink app, and manually activating the scenes in the app is not a solution, we have also automated this using Home Assistant. We also set up two automations to make this work.

One is triggered when we have all left the house and the other is triggered when at least one member of the family has returned home. The trigger can be either a mobile phone location change, a person location change or, as in our case, a group of people. Groups of people are still supported in Home Assistant, but can only be defined in YAML.

Activating the camera notifications when nobody is at home:

The YAML version:

alias: '[Camera] Activate notifications on leaving'
trigger:
 - platform: state
   entity_id:
    - group.jama
   from: home
   to: not_home
condition: []
action:
 - type: turn_on
   device_id: <<< camera 1 >>>
   entity_id: switch.<<< camera 1 >>>_push_notifications
   domain: switch
 - type: turn_on
   device_id: <<< camera 2 >>>
   entity_id: switch.<<< camera 2 >>>_push_notifications
   domain: switch
mode: single

Disabling push notifications follows a similar pattern. There’s an extra check because when we come home late at night, we want the cameras to stay on and we don’t want the notification to be disabled. So this automation only runs before sunset and after sunrise to be in sync with the time-based rules described above.

The script version of this automation looks like this:

alias: '[Camera] De-activate notifications on coming home'
description: ''
trigger:
 - platform: state
   entity_id:
    - group.jama
   from: not_home
   to: home
condition:
 - condition: sun
   before: sunset
   after: sunrise
action:
 - type: turn_off
   device_id: <<< camera 1 >>>
   entity_id: switch.<<< camera 1 >>>_push_notifications
   domain: switch
 - type: turn_off
   device_id: <<< camera 2 >>>
   entity_id: switch.<<< camera 2 >>>_push_notifications
   domain: switch
mode: single

Conclusion

Take control of your push notifications with just four simple automations in Home Assistant. You decide when you want to be notified and when you don’t.
This lets you fill a gap in the Reolink app and add the missing functions yourself.
You can also use Home Assistant to create other useful workflows around the cameras. I’ll explain more in a later article.

I am certain you will find this guide helpful. Please do not hesitate to ask if you have any questions.

Hero image: AI generated with ChatGPT.

How to Integrate Reolink Cameras into Home Assistant

2024-09-13T00:00:00Z

I recently replaced all our security cameras around the house with new Reolink network cameras with either Wifi or PoE (Power of Ethernet). In this post, we will walk through the process of integrating Reolink Network Cameras into Home Assistant. With this integration, you can stream live footage, set up motion detection automations, and even record clips based on events. Here is why, and more importantly, how to set up the new cameras in Home Assistant.

Why I Switched from Arlo to Reolink

If you’ve been following my blog for a while, you know I previously wrote about my experience integrating Arlo cameras into Home Assistant. At the time, Arlo’s cameras seemed like a great option due to their robust features and seamless cloud integration. I was a happy customer for many years. However, things changed with Arlo forcing customers into a cloud subscription and service plan. Without that the already expensive cameras are super limited - IMHO they are useless. Many basic features, like accessing recordings, activity zones and certain smart alerts, are locked behind their premium tiers.

The new camera setup

This made me start exploring more flexible, budget-friendly options that would allow local control over my cameras without being dependent on a cloud subscription. My requirements for the new setup were:

local only, without the need for a monthly subscription plan
enough storage for 24/7 recording (in future) or SD Card
can be powered via power over ethernet (PoE)
Wifi option available
Home Assistant integration possible
bonus points for smart object detection (person, vehicle, animals, parcels)
bonus points for rich push notification

After checking our various options and spending hours on Reddit forums I ended up with Reolink network cameras.

Our setup now consists of 6 cameras:

5MP RLC-540A PoE dome camera at the front door
5MP RLC-520A PoE camera in the carport
2K 4MP CX410 camerawith color night vision
4K Smart Dual-Lens PoE Camerawith super large diagonal via for the garden
2 4K Camera RLC-810WA with Wifi 6 for the garden and pool

Reolink also offers battery powered cameras, dual view cameras or video door bells. Most of them should also work with Home Assistant, however I only could test the cameras listed above.

IMHO Reolink cameras offer excellent hardware at a reasonable price, with features like RTSP, ONVIF and even native home assistant integration, allowing me to maintain complete local control. The camera body is made of aluminium and there is a huge selection of PoE camera options. Best of all, Reolink doesn’t force you into a paid subscription to access key features, and they offer easy integration with Home Assistant for real-time monitoring, motion detection and video recording - no monthly fees.

However, not everything is perfect, and even Reolink’s cameras have a few minor flaws.

Most models, including the one I got, are only available with a white casing. Sometimes (like the RLC-520A) the different colour models have different specifications, such as different lenses.
There is not much room for the antenna mounts on the wifi cameras, such as the RCL-810WA models. If the bracket is very tilted, the antennas cannot be mounted due to lack of space. The solution is a short extension cable such as this one.
Push notification in mixed languages, some cameras send notifications in German like the newer CX410 models, others only in English.

The biggest missing features are camera automation and geo-fencing, as we want to automatically activate the cameras when nobody is at home and after sunset. Arlo was much better at this. The good news is that this problem can be solved by using some automation in the Home Assistant. Finally, we only use the iOS application to view recordings when we receive notifications.

Integrate Reolink Network Cameras into Home Assistant

In the following step-by-step guide I will walk you through how to add your Reolink cameras to Home Assistant with the native Reolink integration. There are alternative integration options, for example using the ONVIF integration or manual RTSP setup as well. However in the guide below I will focus on the Reolink integration only.

What You Will Need

Reolink Network Camera (with firmware that supports the Home Assistant Reolink integration)
Home Assistant
Reolink App credentials (admin user and password)

Step 1: Prepare Your Reolink Camera

Before integrating the camera into Home Assistant, make sure you can access your Reolink camera via the Reolink app or web portal, and it is connected to the same network as your Home Assistant instance.

Optional: Enable the optional camera protocols

Open the Reolink App or web interface.
Navigate to Settings > Network Settings > Advanced.
Ensure that features like RTSP and ONVIF are enabled just in case they are needed for advanced use cases later on (although not required for the integration).

Step 2: Add Reolink Integration to Home Assistant

At first we need to enabled the Reolink integration in Home Assistant.

Log in to your Home Assistant instance.
Go to Settings > Devices & Services > + Add Integration.
In the search bar, type “Reolink” and select the Reolink integration from the list.

Step 3: Add your cameras

Reolink IP cameras - cable network or WiFi connected - can be auto-discovered by Home Assistant. If an device was found, it will be shown as discovered. You can then set it up right away.

If the camera is not auto-discovered it can be manually added by clicking on Add Entry. In the following dialog enter:

Username: Admin or another user with admin privileges set up for the camera.
Password: Camera password.
IP Address: The local IP address of the Reolink camera on your network.
Once entered, click Submit.

Set up a Reolink camera in Home Assistant

Once configured you can change the camera protocol used by Home Assistant to communicated with the camera. You can choose between RTSP, RTMP, or FLV streaming protocol. If there are no streaming issues, lagging video etc. I recommend to leave this setting at RTSP as this should give you the best video results and is the only protocol which can stream 4K camera streams.

Step 4: Confirm the Camera is added to Home Assistant

After submitting your credentials, Home Assistant will automatically communicate with the Reolink camera and set up the connection. If the integration is successful, you will see a confirmation message, and the camera will appear in your list of devices.

Reolink camera integration in Home Assistant

Step 5: View the Camera in Devices

If the Reolink device view is not already open:

Go to Settings > Devices & Services.
Under Devices, you should now see your Reolink camera listed as a device. Click on it to view more information and entities that have been created for the camera (e.g., video feed, motion sensor, etc.).

Depending on the features and capabilities of the camera the Reolink integration creates 40 or more entities for each camera device. It is very verbose and detailed. All the configuration setting you have in the Reolink app are exposed as well in Home Assistant. I personally disable most of the entires in the Configuration group as I do not plan to change these from within Home Assistant. Like for other devices in Home Assistant associated automations and events are shown on the detail view as well.

Camera detail view in Home Assistant

I usually only keep the important switches, the camera stream(s), the motion detection sensors and a small number of configuration settings enabled.

By clicking on the round image, you should be able to access the camera’s video stream. Typically, you will first see a snapshot while the camera stream is loading in the background. Once available, the snapshot image will be replaced by the playing video.

Step 5: Viewing Your Reolink Camera in Lovelace Dashboard

Once the Reolink camera is added to Home Assistant and you have checked the sensors and the camera stream in the device detail view, you can easily view the live video feed from your dashboard.

Go to your Lovelace dashboard.
Click on the three dots in the upper-right corner and choose Edit Dashboard.
Select Add Card and then choose the Picture Entity card.
- Entity: Select the newly added Reolink camera (e.g., camera.reolink_front_door).
- Show Stream: Toggle this option to display the live stream from the camera.

Add camera entity to your Lovelace dashboard

If you manage your dashboards in YAML files the picture entity card can be added via:

type: picture-entity
show_state: true
show_name: true
camera_view: auto
entity: camera.carport_fluent

Once added, you should now see the live feed from your Reolink camera directly on your dashboard.

Conclusion

Integrating Reolink cameras with Home Assistant using the official Reolink integration is powerful and quite simple. With live streaming, motion detection automation and the ability to record clips, you can easily enhance the security of your smart home. Overall I’m super happy with the new setup and I don’t regret switching from Arlo to Reolink.

This step-by-step guide covers everything from setting up the camera to viewing the camera stream in the Home Assistant. In the next post, I’ll share some of my automations and show you how to add the missing geo-fence functionality.

Happy home automation!

ZigBee Temperature and Humidity Sensors: A Comparison

2024-08-28T00:00:00Z

Smart homes are becoming increasingly popular, and temperature and humidity sensors play a crucial role in automating home environments. Over the last years I have added > 10 in and around the house. Every room got one, the attic as well and one was added into the fridge. Of course there is a sensor outside in the garden and a second for to measure the pool water temp.

ZigBee sensors are great for this use case. They are known for their low power consumption and reliable communication. They can run on battery power for several months, even years.

Most of the sensors we have installed are Aqara Temperature and Humidity sensors of the first generation. So far, these have been very reliable and most of them still are. But there are also a few, 3 so far, that have had failures recently and have repeatedly lost the connection. Only a re-paring helped, which is quite annoying. Different batteries, different position, nothing really brings any improvement. That’s why I’ve been looking around for alternatives.

In this blog post, we’ll compare five popular ZigBee temperature and humidity sensors to help you make an informed choice. We’ll evaluate each sensor based on accuracy, battery life, size, ease of integration with Home Assistant, and more.

Overview of the Test Sensors

Before diving into the comparison, let’s briefly introduce the five ZigBee sensors that we will be reviewing:

SONOFF Zigbee Temperature and Humidity Sensor: A budget-friendly option known for its compact design and easy installation.
Aqara Temperature and Humidity Sensor (Old Version): An established sensor that has been a favorite in the smart home community for its reliability and ease of use.
Aqara Temperature and Humidity Sensor T1 (New Version): The upgraded version of the Aqara sensor, offering improved features and compatibility.
NOUS E5 ZigBee Smart Temperature and Humidity Sensor: A lesser-known brand that promises high accuracy and seamless integration.
OWON Zigbee with Remote Temperature Probe on Cable: A unique sensor with a remote probe, designed for more specialized applications where precise placement is necessary.

I have selected sensors that are relatively easy to buy in Europe. They should also be easy to get in America and elsewhere. Therefore I avoided any Tuya sensor and clone. They are often only available via direct import from China and the sensors specs are often not clear.

Comparison of ZigBee Temperature and Humidity Sensors

Feature	SONOFF Zigbee	Aqara (Old Version)	Aqara T1 (New Version)	NOUS E5	OWON with Remote Probe
Model	SNZB-02P	WSDCGQ11LM	TH-S02D	TS0201	THS-317-ET
Temperature Range	-10℃ ~ +60°C	-20℃ ~ +50°C	-20℃ ~ +50°C	-20℃ ~ +60℃	-40°C ~ +200°C
Temperature Accuracy	±0.2°C	±0.3°C	±0.3°C	±0.3°C,	±0.5°C
Humidity Range	5%-95%RH	0 – 100% RH	0 – 100% RH	0 – 100% RH	n/a
Humidity Accuracy	±2% RH	±3% RH	±3% RH	±5% RH	n/a
Atmospheric Pressure Range	n/a	30 kPa – 110 kPa	30 kPa – 110 kPa	n/a	n/a
Atmospheric Pressure Accuracy	n/a	±0.12 kPa	±0.12 kPa	n/a	n/a
Battery	CR2477	CR2032	CR2032	CR2*1	2x AAA
Battery Life	Up to 2 years	Up to 2 years	Up to 2 years	Up to 5 years	Up to 1.5 years
Size	45 x 45 x 17.7 mm	36 x 36 x 9 mm	36 x 36 x 9 mm	40 x 40 x 23 mm	62 x 52 x 15 mm (sensor case)
Special Features	Compact design, magnetic mounting	Compact design, high reliability	Improved range and battery life	High accuracy claims	Remote probe capability, wide temperature rand
Price	$15-$20	$15-$20	$20	$15-$20	$20

Comparison of Temperature & Humidity Readings

To understand how each sensor performs in real-world scenarios, I tested the sensors under similar conditions and recorded their readings. All the sensors were on my desk right next to each other for a week.

Compare temperature measurements of the 5 sensors

Compare humidity sensors readings

From the data recorded in the last 24 hours:

The SONOFF Zigbee sensor shows slight deviations but remains close to the average readings, indicating good accuracy. It reacts more quickly to temperature changes then the Aqara sensors.
The Aqara (Old Version) and new Aqara T1 getting almost identical measurements for temperature, while the humidity values of the old version are minimal higher than the T1 and average.
The NOUS E5 seams to be calibrated very good, the temperature and humidity readings are always in the middle.
The OWON Remote Probe sensor provides readings slightly higher then the other sensors and it reacts more quickly to temperature changes.

Integrating with Home Assistant

The sensors can be used with many ZigBee bridges and hubs, including Philips Hue, Amazon Echo and other ZigBee 3.0 compatible hubs. However, the most common usage is together with a smart home system like Home Assistant. Here’s how you can integrate these sensors into Home Assistant using Zigbee Home Automation (ZHA), the native integration for ZigBee devices into HA.

I can confirm that all the tested sensors work with ZHA without any issue. I am certain that other Home Assistant ZigBee integrations like ZigBee2MQTT and deCONZ will work just as well. Ensure the sensor works with the particular integration by checking the ZigBee Device Compatibility Repository.

Using ZHA (Zigbee Home Automation)

ZHA is a native integration for ZigBee devices within Home Assistant, providing a straightforward way to connect and manage your sensors. It works with a variety of Zigbee coordinator radios and can easily be configured via the Home Assistant UI.

Here’s a quick guide to get started:

Hardware Requirements: You’ll need a ZigBee coordinator, such as the Home Assistant Connect ZBT-1, ITead SONOFF Zigbee 3.0 USB Dongle) or ConBee II USB adapter, to act as a bridge between your ZigBee devices and Home Assistant.
Setting Up ZHA:
- Go to the Integrations section in Home Assistant.
- Click on Add Integration and search for Zigbee Home Automation (ZHA).
- Follow the prompts to select your ZigBee coordinator and configure the integration.
Pairing Sensors: Once ZHA is set up, you can pair your sensors by putting them into pairing mode (usually by pressing a button on the sensor). The sensors should automatically appear in Home Assistant under ZHA devices.
Configuring Entities: After pairing, each sensor will be listed as an entity in Home Assistant. You can rename, group, and set automations for these sensors to fit your specific needs.

Alternative Integration Options

ZigBee2MQTT & deCONZ are other popular and powerful options to integrate ZigBee devices and sensors into Home Assistant.

ZigBee2MQTT allows for a broader range of devices and more advanced configuration options. It works by bridging ZigBee devices to MQTT, a lightweight messaging protocol used by Home Assistant. A full setup requires an MQTT broker like Mosquitto running standalone or as Home Assistant Add-on.

Another alternative to ZHA is deCONZ, powerful integration for ZigBee devices, particularly popular for its detailed device visualization and management. Is has specially requirements on the supported ZigBee gateways and only works with selected radios like the RaspBee II, ConBee II, or ConBee III . I used this before I switched to ZHA and it worked super reliable. The setup requires a few more components. The deCONZ can also be easily installed as a home assistant add-on via the Add-on store. New devices and sensors are usually paired in the deCONZ software, which then exposes them to the Home Assistant.

Summary

When choosing a ZigBee temperature and humidity sensor, consider what features are most important for your specific needs. For indoor usage all for sensors are good choices.

For General Home Use: The SONOFF Zigbee Temperature and Humidity Sensor offers a good balance between price, accuracy, making it an excellent choice for most users.
For “I want an established Brand”: Both Aqara sensors are reliable choices, go with the newer T1 version.
For Specialized Applications: The OWON Zigbee Remote Temperature Probe is ideal for applications needing precise placement and monitoring of specific areas, such as greenhouses or attics.

No matter your choice, integrating these sensors with Home Assistant will allow you to automate and monitor your home environment efficiently, making your smart home smarter and more comfortable.

Happy automating!

Hero image: AI generated with Microsoft Copilot.

The digital notepad box - a DIY e-ink project

2024-05-19T00:00:00Z

E-Ink displays are known for their low power consumption and crisp visibility. They have gained popularity in various DIY projects. After seeing the first threads on the Home Assistant community forum, I got interested in building an e-paper project with ESPHome. I wanted to build a project where I always have the display in view and it shows me all kinds of useful information. I also wanted it to fit on my desk. That’s how the idea of the digital notepad was born.

And as is often the case with DIY projects, I ordered the electronic components without knowing exactly what I wanted to do. I ordered 2 different sizes of e-ink displays. The 2.9" used in this project and a 10.3" version from Waveshare. I had a suitable ESP32 chip board lying around.

After that it took another six months until I had an idea and could start working on it.

Use Cases

There are a huge number of use cases for e-ink displays in hobby projects. Here are a few examples that are easy to implement.

Home Automation Dashboard:.
Turn your home into a smart haven by creating a centralised dashboard that displays real-time data from your smart home devices. Monitor temperature, humidity and other sensor readings at a glance. This often uses old tablets or iPads, which are mounted on the wall. If you have one to spare and can find a good place for it in the house, this is a great idea.
But you can also go a size smaller, which is less conspicuous, but also less interactive, with an e-ink display.
Weather station
Build a sleek weather station that retrieves and displays weather information. With ESPHome you can easily integrate APIs for weather updates and provide a convenient visual representation on the e-paper display.
There are some very cool examples of this in the Home Assistant community, such as the Weatherman Dashboard project.
Task scheduler:.
Using the e-paper display as a task scheduler to display your daily agenda, reminders or to-do lists is another idea. With ESPHome’s flexibility, you can customise the display to suit your specific scheduling needs.
Originally I wanted to build something like this. But I couldn’t connect ESPHome to my work account & calendar.

My Home Automation Dashboard

In this guide we’ll explore how to build an e-ink based display using ESPHome for a Home Assistant home automation dashboard. The information shown on the display can be chosen freely. It can be customised to suit your home. In my case, it’s - quite classically - the temperature inside and outside the house, power consumption and generation of our solar system, key data from the car and the water temperature and status of the pool.

The full source code of the project can be found in my Home Assistant config repo on GitHub.

Hardware

You only need 3 electronic components for the project.

Waveshare 2.9inch e-ink panel
ESP32 based microcontroller - generic or Waveshare Universal e-Paper Raw Panel Driver Board
USB power supply

Depending on which board you choose, you may be able to do without any soldering at all.

But for a nice display you also need a case. Depending on the size of the display, you can use a picture frame or something smaller. It all depends on the application. With a 3D printer you have almost endless possibilities to print an attractive case or holder. Since I wanted to use a small 2.9-inch display for my project and I don’t have a 3D printer, I had to find another solution.

For my notepad box display I built a wooden case. The display should always be visible. Due to its size it could not be too far away. It took me 2 tries to find the right design. The final version is made of plywood with the display at the bottom. The ESP32 microcontroller is located behind the display. The USB port is on the back.

If you get the Waveshare Universal e-Paper Driver Board, no soldering is required. The controller board can be connected directly to the e-paper display. Waveshare and others also sell pre-assembled plug and play solutions. Connect the controller board with power via USB and you are ready to go.

Software

The software stack is quite simple. All you need is ESPHome and Home Assistant. The ESPHome code runs on the microcontroller that drives the display. Home Assistant is responsible for providing all the data you want to display. ESPHome can integrate a number of different sensors. However, I prefer to get the data from the Home Assistant as it is already available and integrated.

The full configuration for my display is available on GitHub. To use the ESPHome configuration, simply copy it to the ESHome Config folder. You can then customise it for your own display and sensors. Change the display layout, data sources and update intervals according to the requirements of your project.

The ESPHome configuration for my e-ink display project consists of 4 sections. Let me explain the most important parts.

1. Setup the hardware

First you have to tell ESPHome which board you are using, how the Wifi connection is and to which pins the display is connected.

substitutions:
 gpio_spi_clk_pin: GPIO25
 gpio_spi_mosi_pin: GPIO26
 gpio_cs_pin: GPIO32
 gpio_busy_pin: GPIO33
 gpio_reset_pin: GPIO27
 gpio_dc_pin: GPIO0

esphome:
 name: homedisplay
 platform: ESP32
 board: lolin_d32_pro

spi:
 clk_pin: $gpio_spi_clk_pin
 mosi_pin: $gpio_spi_mosi_pin
 id: epaper_display

display:
 - platform: waveshare_epaper
   id: epaper
   cs_pin: $gpio_cs_pin
   busy_pin: $gpio_busy_pin
   reset_pin: $gpio_reset_pin
   dc_pin: $gpio_dc_pin
   model: 2.90in
   rotation: 90°
   # 296x128 pixels
   update_interval: 3600s

Two components are needed to configure the display. The display component is a kind of container component for all ESPHome display integrations. It must be used for any type of display such as TFT displays, OLED displays or e-paper displays. It can also be used to drive pixel-based and 7-segment displays.

For an e-ink display such as the Waveshare E-Paper modules, the platform type waveshare_epaper must be specified and the spi component is also required to specify the pins to which the display is connected. The model parameter specifies the display type used ESPHome documentation has a full guide to the list of display variants.

If you connect additional sensors such as a temperature sensor or an ambient light sensor, additional ping and sensor setup is required.

2. Get the data

In my case I get all the data shown on the display from Home Assistant. Hence this is pretty much the only sensor I configured. I also use the time integration to get the current time and to update the display.

sensor:
 - platform: homeassistant
   entity_id: sensor.garden_temperature
   id: garden_temp
---
binary_sensor:
 - platform: homeassistant
   entity_id: binary_sensor.pool_pump_state
   id: pool_pump_state
---
text_sensor:
 - platform: homeassistant
   entity_id: sensor.car_mercedes_l_jm227e_range_electric
   id: car_charging_endtime
   attribute: endofchargetime

3. Display helpers

To display icons and diagrams as well as text, we need a few helpers. Each icon that is used must be defined once. You can use your own images or pictograms or icons of the Material Design Icon library.

I also use the graph component to display sensor values as a line graph for example for the indoor and outdoor temperature.

image:
 - file: mdi:thermometer
   id: icon_thermometer
   resize: 30x30
 - file: mdi:thermometer
   id: icon_thermometer_small
   resize: 22x22
 - file: mdi:car
   id: car
   resize: 22x22
---
graph:
 - id: garden_temp_graph
   sensor: garden_temp
   line_thickness: 2
   duration: 12h
   x_grid: 10min
   y_grid: 20.0
   border: false
   width: 120
   height: 45
   max_value: 35
   min_value: -10
---
font:
 - file: 'fonts/GoogleSans-Bold.ttf'
   id: clock_font
   size: 40
   glyphs: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ':']
 - file: 'fonts/GoogleSans-Bold.ttf'
   id: font_regular_16
   size: 16
   glyphs:
    [
     '&',
     '@',
     '!',
     ',',
     '.',
     '"',
     '%',
     '+',
     '-',
     '_',
     ':',
     '°',
     '0',
     '1',
     '2',
     '3',
     '4',
     '5',
     '6',
     '7',
     '8',
     '9',
     'A',
     'B',
     'C',
     'D',
     'E',
     'F',
     'G',
     'H',
     'I',
     'J',
     'K',
     'L',
     'M',
     'N',
     'O',
     'P',
     'Q',
     'R',
     'S',
     'T',
     'U',
     'V',
     'W',
     'X',
     'Y',
     'Z',
     ' ',
     'a',
     'b',
     'c',
     'd',
     'e',
     'f',
     'g',
     'h',
     'i',
     'j',
     'k',
     'l',
     'm',
     'n',
     'o',
     'p',
     'q',
     'r',
     's',
     't',
     'u',
     'v',
     'w',
     'x',
     'y',
     'z',
     '/',
     'ß',
     '<',
     '>',
    ]

Font files must be saved in a folder next to the config file. ESPHome will load and bundle the configured glyphs during the build process of the config. Any OpenType or TrueType font should work. As the glyphs are rendered as bitmaps, you will need to define multiple fonts, one for each font & size combination. To keep the memory footprint small, it is recommended to list only the characters that are actually used.

4. Main display logic

The main rendering and data display logic is also configured via the display component. All rendering is done through a large lambda configuration option. This allows you to draw on the display, write text, render images, QR codes or diagrams.

It is possible to draw directly on the display or to use so-called Display Pages. These allow you to configure multiple virtual screens that you can switch between. I’m using display pages to group and separate the different values I want to show on the e-pager display. I currently use 4 display pages. Every minute I switch to a new display page and update the display. Lets have a look at one of them:

pages:
 - id: page1
   lambda: |-
    int x, y;
    ESP_LOGI("display", "Updating Page 1: energy");

    // block headline
    it.image(2, 6, id(icon_flash));
    it.print(24, 20, id(font_regular_20), TextAlign::BASELINE_LEFT, "Energie");
    it.line(102, 20, 184, 20);

    // Time & Temp box
    it.strftime(242, 40, id(clock_font), TextAlign::BASELINE_CENTER, "%H:%M", id(sntp_time).now());
    it.strftime(242, 70, id(font_regular_20), TextAlign::BASELINE_CENTER, "%d.%m.%y", id(sntp_time).now());
    if (id(garden_temp).has_state()) {
      it.image(195, 90, id(icon_thermometer));
      it.printf(230, 110, id(font_regular_20), TextAlign::BASELINE_LEFT, "%2.1f°C", id(garden_temp).state);
    }
    it.line(188, 2, 188, 126);

    if (id(energy_today).has_state()) {
      it.image(6, 32, id(icon_sunny));
      it.printf(32, 49, id(font_regular_16), TextAlign::BASELINE_LEFT, "%.1fkWh", id(energy_today).state);
    }
    if (id(storage_level).has_state()) {
      x = 115, y = 34;
      if (id(storage_level).state <= 33) {
        it.image(x, y, id(battery_low));
      } else if (id(storage_level).state <= 66) {
        it.image(x, y, id(battery_medium));
      } else {
        it.image(x, y, id(battery_high));
      }
      it.printf(x+20, y+15, id(font_regular_16), TextAlign::BASELINE_LEFT, "%2.0f%%", id(storage_level).state);
    }
    if (id(consumption_energy).has_state()) {
      it.image(6, 62, id(home_lightning_bolt_outline));
      it.printf(32, 79, id(font_regular_16), TextAlign::BASELINE_LEFT, "%.1fkWh", id(consumption_energy).state);
    }

    if (id(exported_energy).has_state()) {
      it.image(6, 106, id(transmission_tower_export));
      it.printf(32, 123, id(font_regular_16), TextAlign::BASELINE_LEFT, "%.1fkWh", id(exported_energy).state);
    }
    if (id(imported_energy).has_state()) {
      it.image(100, 106, id(transmission_tower_import));
      it.printf(123, 123, id(font_regular_16), TextAlign::BASELINE_LEFT, "%.1fkWh", id(imported_energy).state);
    }

I wanted my display to always show the current time and the outside temperature. To ensure a consistent display and smooth transitions, all display pages have a heading and a line that visually separates the information. You will find these lines of code on all four virtual screens. The rest is individual for each screen, depending on the information displayed.

To render on the display you essentially need three variables. The x & y coordinates of the display’s coordinate system and the information - text, images, graphics - to be displayed. The top left corner of the display is always the origin of the pixel coordinate system. It has the coordinates x=0, y=0.

In the example above, I am rendering 3 lines of text and icons. They show the combined data of our solar system and the electricity produced & consumed. The other display pages work in a similar way.

Adapting to your needs

Before you start tweaking the rendering, I suggest you familiarise yourself with the ESPHome display component documentation. It contains all the basic information explaining how to draw and render on the display.

Configuring ESPHome for your specific e-paper display model may require some trial and error. Especially positioning all the data elements & icons can take some time. I started by drawing some sketches on paper to find out how I wanted the different data points to be displayed. Play with different font and icon sizes depending on the resolution of your display. Depending on the type of data, you can use icons or graphs. Weather conditions, for example, work well with icons. For a long-term history of a sensor, such as temperature or network traffic, line graphs work well.

When you are finished, use the ESPHome add-on in Home Assistant to flash the configured firmware to your ESP32 driver card.

Summary

Building my e-ink display with ESPHome has been a fun and rewarding experience. Whether it’s for real-time weather updates, monitoring home energy consumption or display traffic information, I love how versatile the combo ESPHome & Home Assistant is for such kind of projects. Seeing the notepad box with the display on my desk every day brings me a sense of satisfaction and keeps me connected to my home automation system. I often think about what else might be useful to display. And, of course, what I could build with the second e-ink display that is still on the shelf.

References

Here are some other repos that I referenced from:

Harnessing the Power of the Sun: A Year in Review

2024-03-26T00:00:00Z

In this annual update I give an update on the 2023 performance of our photovoltaic system and comparing it with previous years’ data. This is a follow up to last years post series about the installation and first energy yield numbers (1, 2, 3).

2023 Solar Energy Production Overview

Total solar energy produced in 2023: 8.292 kWh
Average monthly solar energy production: 691 kWh
Month with highest production: May with 1.330 kWh
Lowest monthly production: 93 kWh in December

Diagram 1: monthly energy production 2023

5.180 kWh of the produced energy was consumed by ourselves which is a ration of 62%. The surplus of 3.112 kWh was fed back into the grid.

On the consumption side we used a total of 10.312 kWh of electricity. Most of this was for the heat pump (2.865 kWh), second highest consumer is our car which we charged with 2.095 kWh. 50% (5.180 kWh) of the consumed electricity produced by our selfs and the second 50% we got it from the power grid.

Comparing with Previous Years

2023 vs. 2022: Total energy production in 2023 was significantly lower than the year before. Overall solar energy production decreased 9% from 9.098 kWh to 8.292 kWh

While the summer months (May, June, July and August) were about the same, we produced significantly more electricity in spring 2022, than in the same period in 2023. March and April were very rainy months in our region and the sky was often very cloudy.

November 2023 we got already some snow very early, for the area we live. As a result, next to nothing was produced for two weeks.

Diagram 2: year to year comparison of energy production

Overall, 2023 was still the 2nd best year for our solar system.

By harnessing the power of the sun we have reduced our carbon footprint and already saved more then 12 tones of CO2 emissions. Especially in the summer month were are mostly energy independent and don’t consume many kWh from the power grid.

I’m curious to see what the numbers will look like at the end of the year for 2024. So far the first 3 months are looking very good. January was actually the best January so far.

Hero image taner ardalı from Unsplash

Home Assistant 2024

2024-01-24T00:00:00Z

Since sharing our initial insights into the Home Assistant setup at my first post about our Home Assistant setup, a lot has transformed. It’s time for an update. This article will walk you through the changes, replacements of devices and integrations, additions of new elements, and the tried-and-true components that have proven to be reliable.

Architecture

Since I’m an IT guy I have to draw an architecture diagram 😃 Ok I hope this is not only for me and also helps you to understand the entire setup better.

JaMa Villa 2024 setup

The foundation

The Odroid N2 system has proven to be an extremely reliable and stable system. It is still in use today as it was 4 years ago. The second Raspberry Pi is gone as I consolidated the ZigBee router to the Odroid N2 as well.
While the overall network setup hasn’t undergone significant changes, our home remains an Ubiquiti stronghold. The Unifi USG has been swapped out for the Unifi UDM Pro, a powerhouse that may be deemed a bit oversized for a standard household. Today I my preferable choice would be the more streamlined Unifi Express box.

The main gear and integrations driving our home are:

Device / Solution	Usage
ZHA using SonOff ZigBee 3.0 USB dongle	This is the main ZigBee Hub with over 40 devices connected. All Ikea & Hue light bulbs and LED stripes are connected to the ZHA network. All the window & door contact sensors, plus all indoor and outdoor temperature sensors are on ZigBee as well.
Homematic CCU3	Used to control all Homematic devices, mainly security devices like motion sensors or sirens. Plus a few switch relays for DIN rail mounting.
Rademacher DuoFern	Wireless controller for our electric roller shutters. In fact, the roller shutters were the first smart devices in our house, long before Home Assistant took over the control.
Ubiquiti UniFi	Our home network is operated by UniFi wired and wireless devices. Router, Switches, Wireless Access Points, … all UniFi. Only the DSL Modem is from DrayTek.
Tapo & Hikvision camera’s	The new camera setup uses 100% local cameras without any cloud subscription. These replace the Arlo cameras.
Tasmota & Shelly devices	A bunch of Wifi switches & sockets. The Shelly devices are permanently installed, whereas the SonOff devices, primarily WiFi sockets, find extensive use for powering various Christmas lights both inside and outside the house during the holiday season.

The major changes, compared to our setup from 2020, are:

Cameras

The Arlo cameras go replaced with local network cameras. While Arlo cameras work well with Home Assistant I decided to ditch them for two main reasons: a) Arlo’s shift to a subscription-based model for both new and existing customers, and b) the frequent release of new models without adequate support for older ones.

Our new setup uses network cameras that operate entirely locally and record to either on device SD cards, our NAS storage or a combination of both. At the front door, we’ve installed a high-resolution 4K Hikvision DS-2CD2086G2-IU connected and powered via Ethernet. Around the house, we’ve deployed 4 Tapo C320WS cameras connected via WiFi, recording in 2K. Despite their affordable price point of approximately 50 Euros, the Tapo cameras deliver impressive image quality, especially in low-light conditions.

For recording all camera streams, I’m currently experimenting with various solutions. Initially, I tried Frigate, an open-source and powerful option that requires extensive configuration for optimal performance. However, I encountered challenges with object detection, experiencing numerous false positives and missed animal detections. Currently, I’m testing Scrypted as a home video integration platform in conjunction with HomeKit Secure Video. So far, it has proven to work quite effectively.

Wireless devices

The major change in out smart home setup in the last 4 years was the switch of the ZigBee network. I transitioned from using Deconz with the Conbee II stick to ZHA, utilizing the SonOff ZigBee 3.0 USB dongle. This switch was motivated by the desire to eliminate the Raspberry Pi sidecar, prompting the relocation of two wireless integrations to the main Home Assistant device.

The migration included moving the Rademacher DuoFern stick and custom integration seamlessly. However, for ZigBee, I decided to explore ZHA based on a friend’s recommendation. Building a new ZigBee network and re-pairing around 25 devices took approximately 4 hours.

Over time, the smart home ecosystem expanded with the addition of various sensors, sockets, and devices. Notable additions include the SilverCrest Power Strip with 3 AC sockets and 4 USB outlets, strategically placed on my home office desk.

One noticeable shift was the decline in reliability of Homematic devices, particularly the contact sensors on windows and doors. known for their .

The biggest loser on the wireless device side is Homematic. For some reason out of sudden we had many issues with the contact sensors on the windows and doors. These all got replaced with Aqara Door and Window Sensors. These little beasts are great have a discreet design. They can be hidden in almost any (German) window or door. In 2 years I only had to replace a battery from time to time.

The wireless device landscape also saw the integration of more Shelly switches, such as the Shelly Plus 2PM with a custom 3D printed DIN rail mount, replacing Homematic DIN rail switching actuators.

Next to the Shelly switches we got a bunch of additional Tasmota devices as well. Since the SonOff S20 are not really state of the art any more I switched to Nous A1 which have a nice and compact design and are available pre-flashed with Tasmota firmware.

Other hardware changes

In addition to the main changes mentioned earlier, here are a few other noteworthy hardware updates:

Replaced the old QNAP NAS (T-219P) with a more powerful Synology DS220+ NAS featuring an Intel CPU. This upgrade enables running Docker containers on the NAS like Frigate NVP or Scrypted (see above).
Upgraded our lawn mower robot to a Gardena Sileno life 750, replacing the old Landroid. The new robot can be seamlessly connected to Home Assistant and operates with significantly reduced noise levels during mowing.
Added a fun project to the mix – the Mario Clock has found a place in our house, bringing a touch of whimsy to our smart home setup.

Home Assistant

Add-ons

The add-on list remains largely unchanged from 2020. Similar to many others, the Configurator add-on has been finally substituted with the Visual Studio Code add-on. Additionally, the Grafana and Influx DB add-ons have been disabled and removed since they were not frequently used any more. While Grafana dashboards are aesthetically pleasing, no one looked at them, hence there is little value in maintaining them.

Integrations & Custom Components

Like any other Home Assistant setup, we have many integrations. And with every update or new toys I get the list gets longer:

Dashboards

We primarily still configure Lovelace UI in YAML mode for our Home Assistant configuration. You can find our main Lovelace config file here, and the folder defining the views is here.

I’ve recently cleaned up the configuration, reducing items on the main dashboards and moving more technical entities to an admin dashboard. I’m particularly excited about the new title card, which has replaced many of the basic entity cards. However, I’ve noticed that standard UI cards are not as powerful as Mushroom cards, for example. I’m hoping for some improvements in the entire Home Assistant user interface this year. This can be the final trigger to maybe start rethinking the dashboards and build new using the UI editor instead of YAML files.

Backup

With the introduction of native support for mounted network storage in Home Assistant version 2023.6, I have reconfigured the backup flow. Now, the weekly backups of the entire Home Assistant setup are stored on our Synology NAS. I have detailed the setup in an entire post.

Summary & Outlook

This blog post provides an updated overview of our current 2024 Home Assistant setup, showcasing shifts to ZHA for ZigBee, and integration of Shelly and Tasmota devices. Changes in hardware include a Synology NAS upgrade and a new lawn mower robot.

For this year I plan to move more and more configuration to the UI and get right of the YAML files. I’m looking forward to UI improvements and potential dashboard changes in the future to migrate all my dashboards.

Build your first website with Edge Delivery and document based authoring

2023-11-14T00:00:00Z

For zero to go-live of your first website in 30 min. Is that possible? In this developer step-by-step walkthrough I show you how to build and launch your first size using Adobe’s new Edge Delivery Service.

Here’s what you will learn:

Setting up the GitHub Repo from our boilerplate project
Setting up a document library and connecting it to the project
Publish the first content changes
Run a local development environment & CLI
Change the site styling
Build a first simple custom block

https://www.youtube.com/watch?v=YpLctMRmJdA

Interested in trying it out on your own? Here is our tutorial.

The talk was given on November 6, 2023 at Adobe Developers Live: Content and Commerce conference.

AdaptTo 2023: Unveiling the Future of Adobe AEM Sites

2023-10-05T00:00:00Z

This year’s AdaptTo 2023 conference in Berlin brought an exciting twist to my speaking journey. Unlike previous years, where AdaptTo conference was only virtually, I had the incredible opportunity to hold a keynote presentation in person.

During this keynote, I gave an introduction into the innovation of Adobe AEM Sites – Document-based Authoring combined with Edge Delivery Services, also known as Project Franklin. This next evolution of AEM Sites introduces a fresh authoring and developer experience, promising to create blazingly fast websites.

The presentation covered the architecture of the Edge Delivery Services stack and the core concepts of document-based authoring. It’s packed with practical details to help developers kickstart their projects and quickly launch their own websites.

https://www.youtube.com/watch?v=Hlqowj7WrmM

If you missed the event or want to revisit the presentation, you can download it now.

Home Assistant backup to Synology NAS

2023-07-17T00:00:00Z

Update: With the first two 2025 releases, there were some new features for Home Assistant backups. I have summarised these in a new article. However, the NAS backup steps in this article are of course still valid.

Okay, I don’t think I need to go into detail about why having a solid backup strategy for your Home Assistant solution is important. So I’ll write about how to set it up. I’ve wanted to set up the backup of my Home Assistant installation properly for months. Now that I’ve finally tackled this task, I thought I’d summarize the steps I took.

I’m running Home Assistant on an Odroid N2, and I’m well aware that frequent writes can shorten the lifespan of memory cards. In general a higher quality SD card typically will last longer and can hold multiple years. We also have to consider the entire system, not only Home Assistant itself, but also all add-on like MQTT broker etc. Although this concern primarily applies to SD cards, I wanted to be cautious with the Odroid N2 and its MMC memory.

Until now, I’ve been creating weekly backups directly on the local disk of my Home Assistant server. Later, I manually transferred these backups to our NAS system at more or less regular intervals. Unfortunately, the memory card has filled up multiple times, forcing me to delete older backups.

I previously experimented with syncing backups on Dropbox and Google Drive, but wasn’t really happy with these options either.

However, with the release of Home Assistant 2023.6, native support for mounted network storage was introduced. This feature allows connecting Home Assistant to Windows/Samba (CIFS) or Network File Share (NFS) network shares within the local network. These network shares can serve as media folders or external backup storage.

Now, it’s time for me to give it a try and establish a robust backup strategy.

Home Assistant backup to network storage

In my case I connected Home Assistant to our Synology NAS. The setup steps are pretty well documented for the Home Assistant part, however the NAS or file server part is always a little more tricky and different. I’ll explain how to configure a network share hosted on the Synology NAS as the main backup location for Home Assistant. This will work with other NAS systems (like QNAP) or file servers as well, but might require some different configuration steps to enable the file share.

Setup step by step

With the following step by step you should have no problem to set up your own Home Assistant backup to a network share.

1. Create a Shared Folder

In order to get started, you must create a shared network folder on your NAS. Go to Control Panel > Shared Folder and click Create. Enter a name for the shared folder (such as “Home Assistant Backup”) and select a location. The location options depend on the NAS setup. I only have Volume 1.

Screenshot 1: configuration of Synology Shared Folder

Do not enable the recycle bin feature. Click Next.

On the next screen leave the option at skip. Don’t configure any encryption for the backup folder. You can choose to secure you backup with a password later in Home Assistant.

Click Next. Don’t change anything on the advanced setups and click Next again.

Review the settings and click Next to create the shared folder.

Screenshot 2: configuration of Synology Shared Folder

Review the access permissions and click Apply.

2. Enable NFS access

In this step we will enable NFS file services on the Synology NAS. This step is only needed if not done before during the initial NAS system setup.

In your Synology UI go to Control Panel > File Services and select the NFS tab. If not already checked select the Enable NFS Service checkbox. The screen should look like this:

Screenshot 3: enable NFS services on Synology NAS

3. Make the shared folder accessible via NFS

In the next step we need to enable NFS access and allow Home Assistant to use the newly created network share. I decided to proceed with NFS. CIFS shares are supported by Home Assistant as well, however I could not get it working with my Synology setup.

Select the newly created shared folder from the Shared Folder list in the Control Panel and click Edit.

In the dialog navigate to the NFS Permissions tab and click Create. In the dialog enter the hostname or IP address of your Home Assistant machine.

Screenshot 4: set up NFS Permissions for shared folder

Click Save.

Copy and note down the mount path at the bottom of the NFS Permissions tab.

Screenshot 5: set up NFS Permissions for shared folder

Click Save.

4. Connect the shared folder in Home Assistant

Let’s switch to Home Assistant and connect to the recently created shared folder on your Synology NAS.

Go to Settings > System > Storage in Home Assistant. In the Network storage section you can see all connected network shares. This list might be empty if you have never connected to network storage before.

Click Add Network Storage button.

In the dialog:

enter a name, like “HomeAssistantBackup”
select Backup from the Usage category
enter the NAS server hostname or IP address
select Network File Share (NFS) as the protocol
in the remote share field enter the NFS share mount path you copied in step 3

Screenshot 6: Home Assistant Network Storage configuration

Click Connect.

Home Assistant will not bind the network share and if everything was correct you should see the new network storage in the list of the Network storage section.

If you try to use the CIFS protocol you need to provide a username & password plus the CIFS share name to connect.

5. Change the default backup location

Once the network share is set up, we only need to change the backup location where Home Assistant stores backups.

Go to Settings > System > Backups in the Home Assistant UI. In the right top corner menu select Change default backup location. In the pop-up dialog select the new backup location and click Save.

Screenshot 7: Home Assistant Network change default backup location

That’s it, the next time a backup is created it will be stored on the NAS network share.

6. List the backups

There are three options to list the backups stored on our NAS:

In Home Assistant, navigate to Settings > System > Backups. You will get a list of all backups. In the Location column you can see where these are stored.
Via Home Assistant CLI run ha backup list to see all the backups. The result also contains a location attribute for each backup. Also note the slug attribute. This maps to the NAS file share filename.
On our NAS we can simply check the shared folder contents. Each backup is stored as one .tar file. The filename maps to the slug attribute in Home Assistant.

Example:

backups:
 - compressed: true
   content:
    addons:
     - a0d7b954_ssh
     - core_mosquitto
     - a0d7b954_adguard
     - core_samba
     - a0d7b954_vscode
     - 15ef4d2f_esphome
    folders:
     - share
     - addons/local
     - ssl
     - media
    homeassistant: true
   date: '2023-07-16T11:23:21.072157+00:00'
   location: BackupShareNAS
   name: Backup_16-07-2023
   protected: false
   size: 216.67
   slug: c528818e
   type: full
 - compressed: true
   content:
    addons:
     - a0d7b954_ssh
     - core_mosquitto
     - a0d7b954_adguard
     - core_samba
     - a0d7b954_vscode
     - 15ef4d2f_esphome
    folders:
     - share
     - addons/local
     - ssl
     - media
    homeassistant: true
   date: '2023-07-08T18:00:00.304439+00:00'
   location: null
   name: Backup_08-07-2023
   protected: false
   size: 224.17
   slug: 39b2baaf
   type: full
days_until_stale: 30

Conclusion

Regularly backing up your Home Assistant configuration is crucial to protect your smart home deployment. While Home Assistant has offered that capability for years to backup to a local disk/memory card then transfer it to external storage afterwards - it is not very reliable. By utilizing a network share as backup storage you add an extra layer of security to your backup strategy. With these steps in place, you can rest assured that your Home Assistant configuration is safe and easily recoverable in case of unforeseen events.

Happy automating!

Hero image from Fernando Lavin on Unsplash

New Talk: Developing a good editor experience with Microsoft 365/Google Workspace

2023-06-08T00:00:00Z

In May Adobe hosted the Adobe Developers Live virtual conference for Adobe Experience Manager. The conference focused on building next generation composable services, universal editor, edge delivery and generative AI.

I gave a presentation about the new AEM document-based authoring and how to build an effective editor experience with Microsoft 365/Google Workspace.

Abstract:

A crucial aspect of every project is the structure of the content documents. An author should be able to navigate through the documents intuitively without any problems. We will provide guidelines and tips and tricks on how to structure your content documents. When structuring a document for Experience Manager, it is essential for authors who will contribute content to make it simple and intuitive. This session will explain how to structure content documents in a content first approach letting authors drive the content structure. We will explain best practices, how and when to use sections and blocks and show common project pitfalls to avoid.

If you want to follow up, feel free to reach out or continue the conversation at the Adobe Experience League Forum.

Need for Speed: Why Website Performance Matters

2023-05-09T00:00:00Z

As I have run this website for a few years now and have been doing some re-designs and new stack changes, I have always thought about how the website performs. Over time, I became more and more interested in topics related to performance optimization. Core Web Vitals and that website performance are important for site users, especially people who come here via mobile. Incidentally, this is also a topic I deal with intensively at work 😃

This page now regularly scores 4x 100 in Google Lighthouse tests and is in the top 100 of the Eleventy Leaderboards.

So, what is Google Lighthouse and why are Core Web Vitals important?

Google Lighthouse is a tool that helps website owners and developers to improve the performance, accessibility, best practices, and search engine optimization (SEO) of their web pages. It measures several aspects of a website’s performance, such as page load speed, interactivity, accessibility, and more. Lighthouse generates a report based on these measurements and highlights areas of improvement and suggesting optimizations. The report provides a score out of 100 for each of the categories mentioned above - 4x 100 is the top score.

Core Web Vitals are a set of metrics also introduced by Google to measure and quantify the user experience of web pages based on real-world performance data. The data is collected by users of Google Chrome browser. There are three key metrics that make up the Core Web Vitals:

Largest Contentful Paint (LCP): This metric measures the time it takes for the largest content element of a web page to become visible in the viewport. A good LCP score means that users can see the main content of the page quickly.
First Input Delay (FID): This measures the time it takes for a user to interact with a web page, such as clicking a link or button. A good FID score means that users can interact with the page without delay.
Cumulative Layout Shift (CLS): Means the amount of unexpected layout shifts that occur during the loading process. A low CLS score means that the page layout remains stable while the page loads. Layout shifts are considered as distracting for the users.

Google considers these Core Web Vitals to be critical indicators of a web page’s user experience and uses them as a ranking factor in search results. Good Core Web Vitals therefore also lead to more users on your site from Google.

Google PageSpeed Insights Report for markus-haack.com tested on May 9th 2023

So how can websites be optimized for speed and a good Lighthouse? Here are some things you can do to improve website performance:

Optimize images: Images are often the largest files on a website and can slow down the page load time. Using modern image formats like WEBP or AVIF compress images significantly better than JPEG, reduce their file size and improve page speed.
Optimize page size: Only load resources which are required and remove unnecessary JavaScript and CSS. If possible, load stuff incrementally to not block the browser from initial page rendering.
Minimize HTTP requests: Each request made to the server to fetch a file, such as CSS or JavaScript, adds to page load time. Minimizing the number of requests can help reduce load time.
Use HTTP/2: this can significantly improve the website’s page speed because it allows browsers to simultaneously process multiple requests over the same connection
Use a Content Delivery Network (CDN): A CDN stores website files on servers located around the world, which allows users to access the website from the nearest server, reducing the load time. It works great with static site generators and web site builders like Eleventy.
Use browser caching: Browser caching allows website files to be stored on the user’s device, which can significantly reduce load time for returning visitors.
Optimize code: Clean and efficient code can reduce load time and improve website performance.

Once you test your own site’s Lighthouse you will get detailed recommendations on how to improve the site’s performance.

As a result, websites that load quickly, provide a seamless user experience, and achieve high Lighthouse scores are not only beneficial for the user but also for the environment. Fast and size optimized websites are good for the environment because they consume less energy, which reduces their carbon footprint.

According to the Website Carbon Calculator only 0.03g of CO2 is produced every time someone visits my site. This is cleaner than 96% of web pages tested. (Tested on May 9th 2023).

Why is that: when a website takes longer to load, it requires more data to be transferred, which in turn requires more energy from data centers and servers. This increased energy consumption contributes to carbon emissions and harms the environment.

I have optimized this site to be as small as possible and haven’t sent unnecessary bytes to my users. I recently joined the 250kb Club, 512KB Club and the 1mb.club to show how meaningful this topic is to me. In the future I will try to keep the site footprint under 250kB of data.

Source hero image: Marc Sendra Martorell

Building a Mario Bros. Clock

2023-04-15T00:00:00Z

I’m a big fan of Nintendo and Super Mario since I was a teenager. One of my most played games in my life was probably Super Mario Land on the Gameboy. I still own it and an original Gameboy as well. I recently found a cool DIY project - Clockwise Mario Bros. Clock by Jonathas Barbosa. I absolutely had to rebuild it. With this project you can create your own animated Mario clock. With a nice frame it can be a retro decorative object for any environment.

Hardware

After some research it turned out the project is relative easy to build. All you need is an HUB75 LED matrix display, an ESP32 based micro controller, some jumper wires and a 5V power supply. In addition, you need the Clockwise firmware.

If you already have an ESP32 micro controller board at hand you can use that. For an easy-to-use and integrated solution check out ESP32 Trinity. If you want to build your own PCD this project from @Alexvanheu can help you get started.

As a starting point, I experimented with a breadboard and an ESP32-based microcontroller. Wiring instructions for the display can be found on GitHub. However, I did not like all the wires and wanted them hidden behind the display. In the end I switched to the Trinity board. It can be directly plugged into the LED matrix display HUB75 connector - no wires, no soldering needed. The Trinity comes with touch sensitive buttons, an LDR to control the display brightness, display power control, 5V input and USB-C. It also makes some of the ESP32 pins available for other custom projects.

The typical 64x64 LED matrix displays you get on Aliexpress are available in different sizes. I opted for a 192mm x 192mm version. For the frame I bought a simple gray picture frame on Amazon. If you own a 3D printer you can build a custom frame or case.

To supply the clock with enough power you need a 5V power supply with enough ampere. Minimum 2A, better 3A or higher is recommended. The power needed depends on the display itself and the brightness of the pixels you select.

I use a USB-C power supply with a 2A current for powering my display. When using the Trinity board you can choose between a USB-C or a 2.1mm barrel jack power supply. Be sure to set the correct jumper on the board for USB-C power and remove it while flashing.

Firmware

The Clockwise project page has all the clock skins available to be directly flashed from the website. There are actually five of them: of course Mario Bros. but also a text-based clock, a world clock, a Castlevania skin and a Pac Mac skin.

On the Clockwise website select the clock face you like and directly flash the firmware from within the browser. Make sure you use a browser supporting WebSerial API. Chrome on desktop works fine, Safari on Mac does not. Mobile browsers also don’t work.

To flash the firmware follow these steps:

Go to https://clockwise.page/ and select the clockface you like
Connect the ESP32 device to your computer’s USB port (make sure it is not powered separately yet).
Click on the Flash button.
Select the correct USB port the device is connected to and click on “Connect” - this depends on the operating system and browser you use.
The installer will ask you to install Clockwise firmware - click “INSTALL” and “INSTALL” on the next screen.
Flashing the board will take ~ 2 minutes, then you should see the installation complete message. Click “NEXT”.
The installer will look for WiFi networks to connect to.
Select your local network and enter your password and click “CONNECT”.
Once connected successfully, a message with the button “VISIT DEVICE” will pop up and you can visit the clock settings page.
On the clock settings page make sure you set the right time zone to display the correct time. The default time zone is UTC.

Attention: the time zone lookup is based on ezTime which uses timezoned.rop.nl on port 2342. If you have a looked down network, you need to unblock UDP connections on port 2342 next to the NTP protocol.

That’s it, your Mario Bros. clock is ready. If not already done, the next step could be to put the display in a stylish case or frame.

With the current firmware version 1.1.0 some additional settings can be adjusted from the device settings page: time zone, swap Blue/Green pins (depending on the display type you use), 24h time format and display brightness.

Update Dec. 01 2023
The Clockwise firmware has got a bunch of new releases since the first post. You are now able configure automatic brightness, connect a photoresistor (LDR sensor), customize the NTP server.
You can now also configure the time zone using Posix Timezone string in case the automatic time zone selection (which requires extra network ports) does not work.

The final result

The project is great, thanks to @jnthas.

Going Green: SolarEdge & Home Assistant

2023-03-18T00:00:00Z

Home Assistant is an open-source home automation platform that allows you to connect and control all the devices in your home. It supports a wide range of solar inverters like Fronius, SMA Solar, Solar-Log, GoodWe or SolarEdge. And while SolarEdge already provides an extensive monitoring portal for end users, there are still some reasons to integrate with Home Assistant. Home Assistant lets you design cross-system dashboards or automations that leave the proprietary islands of manufacturers. For example, we can start charging our electric car when we have enough solar power left. This is more cost effective than sending it back to the grid.

In this blog post, we will take a look at how to integrate a SolarEdge inverter with Home Assistant. We will use the out of the box SolarEdge integration and the SolarEdge Modbus integration. It ties directly to the first two posts about our solar installation and our own green energy production.

Two Integration Options

We have two options to get the data from our SolarEdge system into Home Assistant.

Using the built-in, out of the box SolarEdge integration
Via the SolarEdge Modbus custom integration

Installation of 1) is way simpler and pretty straightforward. The inverter data is loaded from the SolarEdge monitoring portal, not via the inverter directly. This will only provide you with the data SolarEdge provides via its cloud APIs and it will also be delayed.

With the custom integration - option 2) - you’ll get more data and technical details, maybe more than you even need. As the data is retrieved directly from the inverter, it is almost as real-time as possible. However the setup of the custom component code requires some inverter config changes (in most cases) and the installation is a little more effort.

If you plan to use the Home Assistant energy dashboard I recommend option 2.

Integrating SolarEdge via the cloud integration

Integrating your SolarEdge inverter with Home Assistant is a straightforward process. This chapter describes how this can be achieved using the out of the box SolarEdge cloud integration which gets the data from the SolarEdge portal. The integration will update the site overview every 15 minutes. This is due to API request limits of the SolarEdge cloud API.

Here are the steps:

Step 1: Obtain your SolarEdge API Key

The first thing you need to do is obtain your SolarEdge API key. To do this, go to the SolarEdge monitoring website and log in to your account. Then navigate to “Admin” > “API Access” page, where you will find your Site ID and the API key. You will need to accept the terms and conditions if this is the first time.

Step 2: Install the SolarEdge Integration

The next step is to install the SolarEdge integration in Home Assistant. This can be done via the “Settings” page in Home Assistant. From there select “Devices & Services” and then click on the “+ Add Integration” button in the bottom right corner. In the dialog search for “SolarEdge”. You will see two options. Select “SolarEdge” with the cloud symbol.

Step 3: Configure the Integration

On the SolarEdge integration configuration screen, enter your SolarEdge Site ID and API key from Step 1. Once done click on “Submit.” Home Assistant will then automatically discover your SolarEdge inverter via the SolarEdge monitoring portal, add it to your Home Assistant dashboard and configure the sensors.

You are now ready to display the data in your custom dashboards or use them for the energy dashboard.

Integrating SolarEdge Inverter using Modbus

The SolarEdge Modbus integration is an alternative way to integrate your SolarEdge inverter with Home Assistant. It can be used as a replacement for the default SolarEdge cloud-based integration or in combination. Instead of retrieving aggregated data from the SolarEdge monitoring portal this method uses the Modbus TCP protocol to communicate directly with the inverter.

Here’s what you need to do:

Step 1: Enable Modbus TCP on Your SolarEdge Inverter

Your inverter must have Modbus TCP enabled. For some inverters you can do it yourself, for others you need an electrician. This depends on the inverter model.

In my case (using SE7K-RWS inverter) is was necessary to set the inverter into installation mode and connect directly to the inverter WiFi. Modbus TCP can be enabled in the “Site Communication” menu. This can be done via the SolarEdge SetApp or via a browser. These steps should be similar for most SolarEdge inverters of the current generation. If you are unsure ask your local solar installer or electrician.

Step 2: Configure the SolarEdge Modbus Integration

The SolarEdge Modbus integration is available as a customer integration. You can installed it via HACS - search for “SolarEdge” - or manually. See instructions on the projects Git repository.
After installation make sure you reboot your Home-Assistant system.

Step 3: Connect the Modbus Integration with the Inverter

On the SolarEdge Modbus integration configuration screen, enter the IP address and port number of your SolarEdge inverter, and click on “Submit.” Home Assistant will then automatically discover your SolarEdge inverter and add it to your Home Assistant dashboard.

Like many other integrations the SolarEdge Modbus integration is installed via the Home Assistant UI. Then navigate to the “Settings” page in Home Assistant. From there select “Devices & Services” and then click on the “+ Add Integration” button in the bottom right corner. In the dialog search for “SolarEdge” and choose “SolarEdge Modbus”. The open box icon indicates that the SolarEdge Modbus integration is a custom integration.

Step 4: Configure the Integration

In the configuration dialog enter the local IP address of your inverter. The TCP port should stay at 1502 and in most cases the Modbus address must stay at 1 as well. This depends a little bit on your setup, if multiple inverters are used etc. Select the “Read …” checkboxes for the meters (up to 3) and batteries (up to 2) you would like to get data for. The integration automatically creates all sensor entities for the meters and batteries.

The SolarEdge Modbus integration can provide very detailed data from the inverter. The integration created 107 sensors for our installation. Not all of them are needed by us. For example, since we have a 3 phase system, I disabled most of the sensors with separate details data for a single phase as I’m only interested in combined data.

Home Assistent Energy Dashboard

While SolarEdge offers a very comprehensive energy monitoring portal it is still a smart idea to set up the Home Assistant Energy Dashboard. The Home Assistant Energy Dashboard provides a more detailed overview of the energy usage of individual consumers. It also provides access to historical data, allowing users to track trends and make informed decisions about their energy usage. Furthermore, it helps you identify your home’s energy-hogging appliances and devices. Once you know which devices are using the most energy, you can take steps to reduce their usage or replace them with more energy-efficient alternatives.

To get the most out of it I highly recommend configuring the SolarEdge Modbus integration as this provides more data points, especially if your inverter has battery storage connected as well.

To setup the Home Assistant Energy Dashboard three sensors are needed - the energy values for solar production, grid consumption and exported energy. If you have battery storage installed you have the option to configure battery in and out aka. charge and discharge energy sensors.

Screenshot Home Assistant Energy Dashboard Configuration

In the “Individual devices” section you can add all devices which provide energy consumption data like washing machines, fridges, wallboxes, lamps etc. If your devices don’t provide energy consumption sensors a smart plug can be used.

Make sure the energy sensors are not excluded if you have a customized recorder configuration in Home Assistant. Only sensors with history recording can be used in the energy dashboard.

If you live in Europe I recommend setting up the Forecast.Solar integration as well, in addition to the inverter and device energy sensors. Based on historical averages and weather forecasts, it can forecast solar power production for your solar panel system. Currently Forecast.Solar only works in Europe. I’m not sure if there is an equivalent service for other regions.

Once configured Home Assistant requires some time to collect enough data until the Home Assistant Energy Dashboard is fully working.

Screenshot Home Assistant Energy Dashboard - 18th March 2023

Let it run for 2-3 days and then come back. Over time, with enough data collected, you will get a very clean and informative dashboard. With the help of the “Monitor individual devices” view it is now easier to find energy hungry devices using individual monitored devices.

For an even more fine tuned configuration of the Home Assistant Energy Dashboard in combination with SolarEgde I recommend checking this thread on the Home Assistant Community.

Conclusion

Integrating a SolarEdge inverter with Home Assistant helps with real-time monitoring and managing of our solar power system. The integration can be achieved using either the SolarEdge API or the SolarEdge Modbus integration. With live data, especially from the SolarEdge Modbus integration we can optimize your energy usage, control electricity consumers and ultimately reduce your electricity bills.

HC-SR04 & JSN-SR04T ultrasonic distance sensors in ESPHome

2023-03-04T00:00:00Z

In relation to my ESPHome water tank project I got a lot of inquiries about how to use an ultrasonic distance sensor with ESPHome. That’s why I created this short guide.

ESPHome is an open-source framework for building Internet of Things (IoT) devices using the ESP8266 and ESP32 microcontrollers. ESPHome provides an YAML-based configuration language for creating custom firmware that runs on these devices. There is no need to learn and code C++ to program the microcontrollers.

The sensors

Depending on the characteristics of your project you have two options of ultrasonic distance sensors to choose from: the HC-SR04 or the JSN-SR04T.

Both sensors are capable of accurately measuring distances between 2cm and ~400cm using ultrasonic pulses and are suitable for a wide range of projects. They both use the same principle of measuring the time it takes for an ultrasonic pulse to travel from the sensor to an object and back.

Here are a few key differences between the two sensors:

Physical size: The JSN-SR04T sensor is larger than the HC-SR04 sensor, which may make it more difficult to fit into small projects.
Waterproofing: The JSN-SR04T sensor is designed to be waterproof, which makes it a better choice for outdoor projects or projects that may be exposed to moisture like a water tank sensor installation.
Cables: The JSN-SR04T typically consists of two parts: the sensor itself and a logic board. Only the sensor itself is waterproof, the logic board is not. The HC-SR04 sensor consists of only one module.
Power consumption: The JSN-SR04T sensor has a higher power consumption than the HC-SR04 sensor. This can be a concern if you are building battery powered projects.
Cost: A HC-SR04 sensor (~1€) is definitely the cheaper option and the JSN-SR04T (~4€) sensor is generally more expensive.

The choice between them will depend on your specific requirements, such as size, waterproofing, power consumption, and cost. While the HC-SR04 sensor can be used universally, the JSN-SR04T sensor is often the better choice for outdoor projects.

ESPHome Ultrasonic Distance Sensor

For the following instructions, I assume that you already know ESPHome. If not, see here for an introduction to the ESPHome. It is recommended that you integrate Home Assistant with ESPHome and use the Dashboard for ESPHome. As an alternative, for non Home Assistant users, there is also the option to use the ESPHome Command Line tool.

HC-SR04 & Wemos D1 mini on the breadboard

Here are the steps to use the HC-SR04 or JSN-SR04T sensor with ESPHome:

Connect the sensor to your microcontroller. I’m using a Wemos D1 mini to illustrate the steps. Both ultrasonic distance sensors have four pins: VCC, GND, TRIG, and ECHO. Connect the VCC pin to a 5V power supply, GND to ground, TRIG to a GPIO pin (I’m using D1) on the microcontroller board, and ECHO to another GPIO pin (I’m using D2).
Create a new ESPHome configuration file for your device. Using the Home Assistant integration you can use the ESPHome wizard. Otherwise create a new YAML file manually.
Add the following code to the configuration file to define the HC-SR04 sensor:

sensor:
 - platform: ultrasonic
   trigger_pin: D1
   echo_pin: D2
   name: 'My Ultrasonic Sensor'

Replace D1 and D2 with the GPIO pins you connected to the TRIG and ECHO pins of your sensor.
Save and upload the ESPHome firmware to your microcontroller using the ESPHome web interface or the command-line tool.
Once the firmware is uploaded and the device is connected to your Wi-Fi network, you should be able to see the distance measurement from the ultrasonic sensor in the microcontroller logs within the ESPHome dashboard or using.

Wiring diagram of JSN-SR04T on the breadboard

That’s it! You now have a working HC-SR04 or JSN-SR04T ultrasonic distance sensor connected to your microcontroller and integrated with ESPHome.

The basic project code looks like this:

esphome:
 name: ultrasonic-sensor
 platform: ESP8266
 board: d1_mini_pro

wifi:
 ssid: 'YOUR_SSID'
 password: 'YOUR_PASSWORD'

# Enable logging
logger:

# Enable Home Assistant API
api:

# Enable over-the-air updates
ota:

sensor:
 - platform: ultrasonic
   trigger_pin: D1
   echo_pin: D2
   name: 'My Ultrasonic Sensor'
   update_interval: 1s
   accuracy_decimals: 2
   unit_of_measurement: cm

In this code, replace YOUR_SSID and YOUR_PASSWORD with your Wi-Fi network’s name and password, respectively. The platform and board options will depend on the type of microcontroller you are using. For a generic ESP8266 board use board: nodemcuv2.

Fortunately, HC-SR04 and JSN-SR04T use the same data interface. The code works for both ultrasonic distance sensors in the same way. Once running the log from ESPHome will look like this:

[14:49:45][I][app:102]: ESPHome version 2023.2.4 compiled on Mar 4 2023, 14:48:45
[14:49:45][C][wifi:504]: WiFi:
[14:49:45][C][wifi:362]: Local MAC: 2C:3A:E8:1F:60:26
[14:49:45][C][wifi:363]: SSID: [redacted]
[14:49:45][C][wifi:364]: IP Address: 192.168.30.72
[14:49:45][C][wifi:365]: BSSID: [redacted]
[14:49:45][C][wifi:367]: Hostname: 'distance-sensor'
[14:49:45][C][wifi:369]: Signal strength: -61 dB ▂▄▆█
[14:49:45][C][wifi:373]: Channel: 1
[14:49:45][C][wifi:374]: Subnet: 255.255.255.0
[14:49:45][C][wifi:375]: Gateway: 192.168.30.1
[14:49:45][C][wifi:376]: DNS1: 192.168.1.3
[14:49:45][C][wifi:377]: DNS2: 192.168.30.1
[14:49:45][C][logger:293]: Logger:
[14:49:45][C][logger:294]: Level: DEBUG
[14:49:45][C][logger:295]: Log Baud Rate: 115200
[14:49:45][C][logger:296]: Hardware UART: UART0
[14:49:45][C][ultrasonic.sensor:045]: Ultrasonic Sensor 'Ultrasonic Sensor'
[14:49:45][C][ultrasonic.sensor:045]: State Class: 'measurement'
[14:49:45][C][ultrasonic.sensor:045]: Unit of Measurement: 'm'
[14:49:45][C][ultrasonic.sensor:045]: Accuracy Decimals: 2
[14:49:45][C][ultrasonic.sensor:045]: Icon: 'mdi:arrow-expand-vertical'
[14:49:45][C][ultrasonic.sensor:046]: Echo Pin: GPIO4
[14:49:45][C][ultrasonic.sensor:047]: Trigger Pin: GPIO5
[14:49:45][C][ultrasonic.sensor:048]: Pulse time: 10 µs
[14:49:45][C][ultrasonic.sensor:049]: Timeout: 11661 µs
[14:49:45][C][ultrasonic.sensor:050]: Update Interval: 10.0s
[14:49:45][C][captive_portal:088]: Captive Portal:
[14:49:45][C][mdns:108]: mDNS:
[14:49:45][C][mdns:109]: Hostname: distance-sensor
[14:49:45][C][ota:093]: Over-The-Air Updates:
[14:49:45][C][ota:094]: Address: distance-sensor.lan:8266
[14:49:45][C][ota:097]: Using Password.
[14:49:45][C][api:138]: API Server:
[14:49:45][C][api:139]: Address: distance-sensor.lan:6053
[14:49:45][C][api:141]: Using noise encryption: YES
[14:49:46][D][ultrasonic.sensor:040]: 'Ultrasonic Sensor' - Got distance: 1.52 m
[14:49:46][D][sensor:126]: 'Ultrasonic Sensor': Sending state 1.52258 m with 2 decimals of accuracy
[14:49:56][D][ultrasonic.sensor:040]: 'Ultrasonic Sensor' - Got distance: 0.76 m
[14:49:56][D][sensor:126]: 'Ultrasonic Sensor': Sending state 0.75717 m with 2 decimals of accuracy
[14:50:06][D][ultrasonic.sensor:040]: 'Ultrasonic Sensor' - Got distance: 0.99 m
[14:50:06][D][sensor:126]: 'Ultrasonic Sensor': Sending state 0.98938 m with 2 decimals of accuracy
[14:50:16][D][ultrasonic.sensor:040]: 'Ultrasonic Sensor' - Got distance: 1.52 m
[14:50:16][D][sensor:126]: 'Ultrasonic Sensor': Sending state 1.51777 m with 2 decimals of accuracy
[14:50:26][D][ultrasonic.sensor:040]: 'Ultrasonic Sensor' - Got distance: 0.27 m
[14:50:26][D][sensor:126]: 'Ultrasonic Sensor': Sending state 0.27440 m with 2 decimals of accuracy

Advanced ESPHome configuration

ESPHome has some powerful features that allow you to manipulate sensor values as well as automate the process of sending data before sending it to Home Assistant.

filters allow you to pre-process sensor values like adding offset or multipliers, calibrate the output or calculate median, moving average, min, max and more
state change events help building automations and run a lambda function on sensor state changes

Using filters

Some handy filters that can be used in combination with ultrasonic distance sensors are:

filter_out

filters:
 - filter_out: nan

filter_out can be used to filter out specific sensor readings. For some projects the ultrasonic distance sensors can sometimes give undefined data which I would like to ignore, for example if the distance gets too large for the sensor.

median

filters:
 - median:
    window_size: 7

This filter is useful to filter outliers from the received sensor data. Using the window_size option you can control the number of values over which to calculate a moving median.

min & max

Similar to the median filter these help to calculate a min or max value based on a defined number of sensor value readings.

filters:
  - min

or

filters:
  - max

offset & multiply

filters:
 - offset: 2.0
 - multiply: 1.2

Using offset you can add a constant factor to the sensor value. With the help of multiply you can multiply each sensor value by a constant value. For the distance sensor this can be helpful for converting the units of the measurements. In order to adjust the value of ultrasonic distance sensors to centimeters and inches, they need to be filtered with a multiply filter.

calibrate_linear

filters:
  - calibrate_linear:
      - 0.0 -> 0.0
	  - 10.0 -> 12.0

With the calibrate_linear filter you get a powerful mapping tool for the sensor values allowing you to transform the measured values with an accurate “truth” source. You need to provide two ranges and a linear equation function is applied. This filter becomes handy if the sensor does not return accurate values or if you need to map the sensor values into another range.

Sensor automation

Sensor events provide the possibility of running automations directly on the micro controller board. No Home Assistant or server is needed. The available sensor events are:

on_value

Using the on_value sensor event an automation can be triggered to run a lambda function. The function can access the sensor trigger value by using the x variable. Sensor automations are triggered after sensor filters have been applied. If filters are configured for a sensor x has already the pre-processed value.

on_value:
 then:
  - sensor.template.publish:
     id: garden_watertank_liter
     state: !lambda 'return x * 3.1415926;'

As shown in the example, a second template sensor is updated with a new value. You can also use it to toggle a light or switch.

on_raw_value

on_raw_value works similar like the on_value event, but as the name implies you have access to the direct sensor value that hasn’t passed through any filters.

on_value_range

With the on_value_range even you can run automations if a sensor value passes from outside a defined range of values to inside a range. By combining this with a distance sensor, a notification can be triggered when the sensor value exceeds or falls.

Find more about ESPHome sensor automations on the ESPHome web page. In my water tank sensor project I use some of these filters and a simple automation to update linked template sensors. The water tank sensor project utilizes a JSN-SR04T ultrasonic distance sensor to monitor the water level in our water tank. The data collected by these sensor is send to Home Assistant.

Going Green: Our Own Electricity

2023-02-27T00:00:00Z

In part 2 of my “Our Own Electricity” series I give an insight into our electricity production and consumption. After I explained our setup I will share details on the installation costs, our break even calculation.

Disclaimer: the numbers below are actual numbers from our installation. There will be differences in numbers based on the place where you live, the local regulations and the hours of sun you get.

Energy Production

The initial estimates of electricity yield from the sales offers were all around 9 MWh per year. Of course, I knew that they were all overestimated, people wanted to sell us a photovoltaic system.

I now have real data from 2.5 years. First overall I am very satisfied with the energy production of our installation.

Energy production 2020 - 2023 - yearly summery

In 2021, the first full year, our photovoltaic system produced 7,78 MWh. I’m very happy especially with the electricity production in 2022. Last year we had very sunny spring and summer and could produce 9,1 MWh. This is even a tiny bit higher than the initial estimates.

Energy production 2020 - 2023 - per month

In 2022 the electricity yield was higher than in 2021 in all months except December. See light blue bars in the diagram above. Only 60 kWh were produced throughout December 2022. We can produce almost the same on a summer day in July or August. We produce approximately 90% of the electricity between March and October. Darker winter months - November till February are usually very low in electricity yield. Living in central Europe 51° N there is not much sun during these month. And when the sun shines, it only shines for a few hours and at a flat angle.

Last years we didn’t had much snow at the place we live. But if we had some it usually stayed for a while. During that time no electricity is produced even on sunny days if the panels are covered with snow. In December 2022 we had exactly such a case. It snowed for two days and then one week of super sunny winter days but the snow didn’t melt.

Overall we get 50% of the electricity yield in 1/3 of the time. During the summer months May till August we produce > 1MWh each month. April 2022 was also close to 1MWh. The rest of the year the electricity yield is lower, especially during the winter months.

Effect of the battery storage

In retrospect it was a good decision to install a battery. I was initially skeptical as to whether it would be worth it, especially because of the extra acquisition and installation costs calculation below.

In 2022 we consumed 38% (2.145 kWh) of our self produced electricity from the battery. Like any battery, a solar battery storage also has a low energy loss. The manufacturer claims it has over 90% efficiency. So we loaded ~ 2.383 kWh into the battery to get 2.145 kWh out. Without battery this would be send to the grid during the day and consumed from the grid during the evening our. This saved us over 400 Euro, see calculation below.

A typical battery charging and dis-charging curve on a summer day looks like this:

Sample battery charging and dis-charging curve

Making the maths

Ok how profitable is the whole thing now really. The numbers below are from the initial calculation I made during our planing phase end of 2019. With the current energy crisis 2022 here in Europe and especially in Germany, the savings for every kilowatt hour that we produce ourselves are even higher. While paying lot more for electricity consumed from the grid we also save more money for every kilowatt we produce ourselves and don’t consume from the public grid.

Acquisition costs

When reading this part please keep in mind that we installed the solar panels early 2020, more than two years ago. Prices cannot be compared one-to-one with today’s price ranges for photovoltaic hardware, batteries and installation service costs. The cost of photovoltaic hardware, batteries and installation services have increased significantly since the installation of our system two years ago.

Our installation costs are made up as follows:

Item	Amount
Photovoltaic system	11.407,46 €
BYD battery storage	5.765,07 €
Electric assembly DC & AC	3.811,00 €
Delivery	328,00 €
Total (pre tax)	21.311,53 €
VAT 19%	4.049,19 €
Total (incl. tax)	25.360,72 €
Battery storage funding	-3.200 €
Final installation cost	22.160,72 €

The first row of the table includes the 27 Qcells solar panels, the SolarEdge inverter, 27 SolarEdge optimizers, substructure, cables, and assembly on the roof. The electric assembly package contains the DC cable installation, connecting everything to the inverter, connecting the converter with the AC election installation in our house, installing overvoltage protection, all the cabels and configuring the SolarEdge inverter with the right parameters.

As part of the Sächsische Aufbaubank funding program, we received 3.200 € for the installation of a photovoltaic battery system. Most likely, we wouldn’t have installed a battery storage system without the funding. By the end of 2019, electricity costs would not have made the purchase worthwhile. Luckily we did. However since electricity costs a lot in 2019, the calculation would be different now and today I would recommend to install a photovoltaic battery for most set ups.

Impact of the battery storage

As written above in 2022 we consumed 2.145 kWh out of the photovoltaic battery. The photovoltaic battery, like every other battery, has some loss of charge. The energy amount loaded into the storage system was ~ 2.383 kWh.

Would these 2.383 kWh have been sent back into the grid we would get some compensation for it.

2.383 kWh * 0,0967 € = 230 € of theoretical compensation

The same time we would have drawn the 2.145 kWh from the grid instead from the battery. The price for that, with rates of 2022, would be:

2.145 kWh *  0,2996 € = 643 € of theoretical electricity cost

The battery saved us approximately 413€ in one year. Giving the installation cost of the battery system (3200€) the investment is recovered after 8 years.

Savings & break even

Our self-produced electricity saves us a few hundred euros on our electricity bill. Based on the final installation costs of 22.160,72 € for the entire system, we calculated that the break even point would be after 18 years. How is it today?

Production and Consumption overview for 2022

We reached 62% self-consumption on the production side in 2022. 3.460 kWh (= 38%) have been feed into the grid. For each kWh we don’t use ourselves and feed into the grid we receive 0,0967 € feed-in tariff. This amount is guaranteed for 20 years by the
Erneuerbare-Energien-Gesetz (EEG = Renewable Energy Sources Act in Germany).

For 2022 this means:

3.460 kWh*  0,0967 € = 334,97 €

On the consumption side we ended up with 56% self-consumption out of 10.150 kWh consumed energy. This means 5.640 kWh we did not consume from the grid.

5.640 kWh *  0,2996 € = 1689,74 €

with 0,2996 € = our price per kWh in 2022

In the end, we gained the equivalent of 1.689,74 € of free electricity. A lot of money was saved on the electricity bill. Due to the difference between the consumption tariff and the feed-in tariff, optimizing for self-consumption makes the most sense. We save more money on every kWh of self-produced electricity than we receive for grid excess energy.

In total, savings on self-consumption plus money from electricity feed-in, we “earned” 2.024 €. Based on that projection, the break even point should be reached within 12 years. With the updated, increased consumption rates we already got for 2023 of 0,52 € per kWh this we should hit it even earlier.

My original plan was to write an extra section about taxes as well. But I would only be able to explain the rules for Germany and even here I’m not a tax expert. Other countries have different laws and tax rules and even here in Germany things are constantly changing. So I will skip that part as it would likely be outdated at the time of writing.

Grand total

So far we are pretty happy with our installation. By installing a photovoltaic system, we have been able to save money on our electricity bills, as well as earn some money from the sale of our excess electricity. We earned a value of 2.024 € in 2022 (1.631€ in 2021). Installing the photovoltaic system was definitely the right choice if this continues in the coming years.

We save money on and do something good for the environment at the same time.

In the next post I will explain how I integrated our photovoltaic system with Home Assistant to get more detailed data and electricity monitoring for our entire house.

Hero image photo by Daniel van den Berg on Unsplash

Going Green: Installing a Solar System

2023-01-08T00:00:00Z

This one has been in my draft folder for a few weeks. Our photovoltaic system was installed in spring 2020 and I wanted to report on it earlier. I finally had some time to finish the article over the holidays. Small side effect of the fact that it took a bit longer: by the end of 2022 I will have two full years of electricity yield data to show and compare.

This article will consist of 3 blog posts because there are too many topics I would like to cover. This first article describes our journey, the motivation behind why we installed it in the first place and the technical setup. In part two, I will cover the numbers, the hard facts, about the electricity yield, our savings on the energy bill. I will also share our financial summary of when we expect to break even. In a third post I will explain how the solar system is integrated into our Home Assistant setup.

Why Solar

We had already thought about installing a photovoltaic system and put solar panels on our roof a few times before.

Summer 2019 was the time to finally implement the project. Next to the obvious reasons to save money on our energy bills and having some protection against rising electricity costs there was another driver for this project: the pool we built in spring 2017 in our backyard. Due to this we have increased power consumption in summer - exactly when the sun is shining. The pool pump, which runs for at least 12 hours a day, depending on the temperature, consumes a lot of electricity. The warmer it is, the longer the pool pump has to run and the higher the power consumption.

Based on our estimates from 2019 - with am electricity rate of 0,28 € per kWh and an investment of ~ 22k € - break even was projected for about 12-14 years. I will go into more detail in part 2 about our investment calculation.

Germany has the highest electricity prices in Europe:

![European electricity prices 2021](/assets/images/pricelist-2021.png ‘European electricity prices 2021, Source: Eurostat: electricity prices by type of user’)

We have already calculated that electricity prices will increase anyway. But we could not foresee that increase now with the energy crisis we have in Europe. Current rates for kilowatt-hour in German are ~ 0,43 € per kWh. With that break even should be already a few years earlier.

We also bought a hybrid car in 2021 and try to drive as much as possible on electricity. Another big electricity consumer and confirmation that producing our own electricity was a smart idea.

Our setup

Tech specs …

27 Hanwha / Q.Cells DUO-G8 panels with 350 Watts peak power each
Solaredge optimizers P370
Solaredge inverter SE7K-RWS
BYD L10.5 battery storage

We installed 27 solar panels on the roof. Each can produce a peak of 350 Watts. Our house has a hip roof. We installed solar panels on the east, south and west side of the roof with a total of 9,45 kilowatts peak output.

Simulated solar panel placement on our roof

We didn’t install solar panels on the north side because there was a 10 kilowatt peak output limit in Germany in 2019. If you exceed this, you have to install an extra switch-off device from the electricity network operator. With this, the grid operator can disconnect the system from the grid or turn down the power at any time. For example, too much electricity is available on the grid. Extra installation costs - that were not worth it at the time. This limit was raised to 25 kilowatts peak output in 2021. So today we would probably also install panels on the north side.

We decided to go with a StorEdge 3 phase inverter system (SE7K-RWS) from SolarEdge with special optimizers. It can operate at a maximum of 7 kilowatts. Given the 3 roof sides have no full sun at the same time this should be more than enough. In the morning, the east side gets the most sunlight while the west side has shadows. In the evening, it’s the opposite. Panels installed on the west side produce electricity while panels on the east get almost no output. We also have a chimney on the west roof that casts shadows on the solar modules.

With the installed optimizer, we will be able to produce more energy, especially if not all of the panels receive the same amount of sunlight. The optimizer can help to maximize the energy output of each solar panel, leading to increased overall energy production from the entire photovoltaic system. Additionally the Solaredge optimizers come with built-in monitoring capabilities. Each solar panel can be monitored individually. This is mostly a tech nerd argument, but it can help diagnose and troubleshoot problems with the photovoltaic system.

SolarEdge individual panel monitoring

The two biggest disadvantages of this setup are cost and compatibility. Each optimizer adds 80€, ~2k € to our installation. Also they are only compatible with Solaredge inverters, so we have to stay with one vendor and cannot install another inverter.

The StorEdge inverter can also connect 48V low voltage batteries directly. Our battery storage solution consists of a BYD Battery-Box LV with a capacity of 10,5 kilowatts. The battery is charged and discharged with max. 5 kilowatts.

SolarEdge’s mobile app and portal let you monitor the StorEdge inverter as well as the BYD Battery Box.

Installation

As soon as the contract with the solar installation company was signed, the installation of our solar system was scheduled for early 2020. At the beginning of 2020, COVID really got started in Europe. Lockdown, schools closed, everyone sent to the home office, people began hoarding toilet paper - ideal conditions for installing a solar system.

Up on the roof

We were lucky with the weather in February 2020. It was cold but dry, so the roofers were able to install the solar panels at the end of February. Delivering panels, setting up scaffolding and assembly of the substructure and solar panels on the roof - everything was done in 3 days.

From then on it got complicated. Nothing happened in the next few weeks. Germany went into lockdown. The delivery of the inverter was delayed only by two weeks - that was nothing. We got the message that delivery of the battery system from China was delayed indefinitely. The electrician had to wait for the electricity network operator’s employees. They were all working from home, not allowed to work on the side. It took us over a month to get an appointment with a service technician.

After the network operator’s technician replaced the energy meter, the electrician could finish the installation. Still took 2 weeks as the electrician had kids at home. Remember we were still in lockdown, the schools were also closed. All the setup was done in mid-April. Apart from annoying calls to the electricity network operator’s hotline to get an appointment, nothing happened for the next month and a half. Finally we could get an appointment with a service technician scheduled for May 28th for the final inspection. Everything was fine and connected properly. Finally, more than 3 months later than planned, at 2:30pm we could flip the circuit switch and start producing our own electricity.

Electricity production of our photovoltaic system on day 1

The entire setup was completed 2 months later with the battery storage installed in July 2020.

All the paperwork

Commissioning a solar system in Germany requires a lot of paperwork, phone calls, and yes even in 2019, sending a fax.

The photovoltaic system has to be registered at with many organisations:

the local electricity network operator
the electricity provider company (because our electricity meter go replaced)
the German “Bundesnetzagentur” (Federal Network Agency for Electricity, Gas, Telecommunications, Post and Railway)
and finally the tax office

The solar installation company took care of most of those, at least the complex and time-consuming communication with the electricity company. They had countless forms, some with identical information, about our installation, electrical parameters, etc. that had to be filled out. Only after approval by the local electricity network operator we are allowed to operate the solar system and connect it to the grid.

Registering the solar system and later the installed battery in the German Marktstammdatenregister (MaStR) is a legal obligation. At least this part can be done online. Why is this needed? I’m not an expert here but I feel mostly for data collection and statistics by the government. So my small home solar system and myself, as an electricity provider, are now registered in a database - next to the big power plants and energy provider companies.

Last but not least, in Germany you have to notify the tax office that a solar system has been installed. With that I’m now running a business as an electricity provider that requires me to pay sales tax for the energy I produce. More on tax for solar systems see below.

Our own clean energy

With the installation done we are now finally producing our own clean, carbon free electricity. This feels good.

CO2 emission saved by us

In part 2 I will show the details of the energy we produce and the financial calculation of our installation.

New Talk: How to Build Content and Commerce Experiences Using App Builder and API Mesh

2022-12-07T00:00:00Z

Last November, Adobe hosted the Adobe Developers Live Headless. The event focused on building modern experiences with AEM Sites headless.

Together with my colleagues Mark & James I gave a presentation about how to build a Content and Commerce Experiences with AEM Sites & Adobe Commerce.

The talk discussed the use of the App Builder and API Mesh to create content and commerce experiences. We guided developers through the end-to-end flow of building a headless experience driven commerce storefront.

Starting with AppBuilder API Mesh to aggregate different content sources from Adobe Experience Manager & Commerce
Learn how to build headless experience displaying products enriched with Adobe Experience Manager Content Fragments
Use Micro Frontends for to integrate a shopping cart into your application

Enjoy the recording of our presentation.

Your browser does not support the iframe element.

The source code of the project built during the presentation can be found on GitHub.

Find all recordings of the Adobe Developers Live Headless at Adobe Experience League.

The Moving Spiders

2022-11-15T00:00:00Z

Little spiders on your shoulder

For this year’s Halloween project I built something without pumpkins. The small moving spiders are to scare our guests. During the party, we placed it over the buffet table. A second one was placed in such a way that it reached down to the kids’ shoulders when they were standing at the buffet and didn’t suspect anything. Using small motors, the spiders moved up and down on their own.

https://www.youtube.com/watch?v=wgdrPl0-C9E

Parts & Tools

The following components & tools are needed to assemble the project:

ESP8266 (Wemos D1 mini, Nodemcu) or ESP32
L298 dual motor bridge board
two slow motors with ~100-200rpm, I went with micro gear motors
prototyping board
male & female pin headers
material for a small roller to wind up the thread
two spiders or scary items
USB cable and power supply
soldering iron

Hardware assembly

The wiring of electronic parts is straightforward. For the small motors, usually no extra power source is required. The L298 dual motor board can be directly connected to the 5V and GND of the ESP board. Additionally, 4 wires are needed to control the motors. A forward and reverse signal is needed for each motor. These must be connected to the digital pins of the ESP board.

The motors are also powered by the L298 dual motor board directly.

Here is my prototype and wiring diagram:

First prototype on a breadboard

Wiring diagram

For the final assembly soldered the cables and some headers to a Wemos protoboard. The Wemos D1 Mini is mounted on top. For the motor controller I chose with an L298 dual motor board. No extra soldering is needed here.

The assembly of the motor part and the cylinder for winding the thread requires some trial and error. As for the construction, I chose wood. 3D printing a bracket would maybe be a better option, but I don’t have a 3D printer 😃

The most tricky part is the cylinder. It took me three tries to get the drilling to mount the motor into the cylinder correctly. The small micro gear motors do not produce much torque. Even the slightest tilt blocks the motor.

My final construction looks like this:

This got directly mounted to the ceiling.

Software

This time I created the software using ESPHome. Controlling two motors is easy and can be done with a simple ESPHome sketch. No complex Arduino C development is needed.
ESPHome has support for the L298 motor controller via the fan integration. That’s why you will see fan commands in the code.

The forward and reverse pins for each motor are defined in the output block. These are connected to a (fan) motor by the fan block, which we can use later to control the motor direction and speed.

output:
 - platform: esp8266_pwm
   id: motor1_forward_pin
   pin: D2
 - platform: esp8266_pwm
   id: motor1_reverse_pin
   pin: D1
 - platform: esp8266_pwm
   id: motor2_forward_pin
   pin: D5
 - platform: esp8266_pwm
   id: motor2_reverse_pin
   pin: D6

fan:
 - platform: hbridge
   id: motor_1
   name: 'Motor 1'
   icon: 'mdi:spider-thread'
   pin_a: motor1_forward_pin
   pin_b: motor1_reverse_pin
   decay_mode: slow
   on_turn_on:
    - logger.log:
       format: 'Motor 1: on - duration = %d ms, direction = %d'
       args: ['id(motor_1_duration)', id(motor_1).direction]
   on_turn_off:
    - logger.log: 'Motor 1: off'

 - platform: hbridge
   id: motor_2
   name: 'Motor 2'
   icon: 'mdi:spider-thread'
   pin_a: motor2_forward_pin
   pin_b: motor2_reverse_pin
   decay_mode: slow
   on_turn_on:
    - logger.log:
       format: 'Motor 2: on - duration = %d ms, direction = %d'
       args: ['id(motor_2_duration)', id(motor_2).direction]
   on_turn_off:
    - logger.log: 'Motor 2: off'

In the program I defined two virtual switches to enable/disable the motor automation remotely for example via Home Assistant. The automation itself is an interval based script with some random variable to add some variance in the up & down movement.

interval:
 - interval: 1min
   then:
    - globals.set:
       id: motor_1_duration
       value: !lambda 'return (rand() % 8) * 1000 + 3000;'
    - if:
       condition:
        switch.is_on: program_1
       then:
        # forward
        - fan.turn_on:
           id: motor_1
           direction: forward
        - delay: !lambda 'return id(motor_1_duration);'
        - fan.turn_off: motor_1
        # pause
        - delay: !lambda 'return id(motor_1_duration);'
        # reverse
        - lambda: |-
           id(motor_1_duration) += 3000;
        - fan.turn_on:
           id: motor_1
           direction: reverse
        - delay: !lambda 'return (id(motor_1_duration));'
        - fan.turn_off: motor_1

Both motor automations follow the same pattern:

Set the duration variable with a random number
Turn motor on
Wait for duration time
Turn motor off
Wait for duration time
Turn motor on in reverse direction
Wait for duration time
Turn motor off
Start with 1.

It even integrates with Home Assistant automatically with ESPHome. This is not really necessary as the motor control part runs automatically, but it is also fun to manually move the spiders up & down. It took some time to get the right values and ranges for motor_1_duration and motor_2_duration. They depend on the rotation speed of the motors, the weight of the spiders on the thread, and the height of the ceiling. Some trial and adjustment is needed.

In Home Assistant I can turn on/off the automations using the virtual switches and control the motors directly. I can also set the motor speed and change the direction.

Screenshot Home Assistant

As usual the source can be found in my GitHub repository:

The final result

The kids at the party had a lot of fun with the spiders. At first, they hadn’t seen them coming down from the ceiling and were absolutely scared. Next year, to level it up, I will try to get some spiders with blinking LED eyes.

The spider in action

The world of Wemos D1 Mini Boards

2022-09-26T00:00:00Z

Some readers recently asked me about the Wemos D1 mini usage in my projects and how this board can be used with ESPHome.

For most of my Arduino & ESPHome projects I use a Wemos D1 mini (v3.1.0) or Wemos D1 mini Pro (v1.1.0) and recently the Wemos D1 mini v4.0. The fourth board of the family is the is the D1 mini light. I never used one of the light versions, most of the time you can get the D1 mini & D1 mini pro for almost identical prices at alipexpress.com.

The boards are equipped with a ESP-8266EX chip running at 80 or 160MHz, like many other Node MCU boards. They provide 12 I/O pins - 11 digital and 1 analog input pin - enough for the most projects.

I also like the board because it is little smaller than a classic Node MCU board. The dimensions are 34.2 mm x 25.6mm. It is so small; it even fits into a small dollhouse Mini TV.

Wemos recently upgraded both boards. The Wemos D1 mini is now on version 4.0.0 and the Wemos D1 mini Pro on v2.0.0. Both boards got USB type C connectors instead of micro USB. The pro version also got a lithium battery interface charging interface and a LOLIN I2C Port. To fit everything on the board D1 mini Pro has grown a bit.

Pinout

The pinouts of the D1 mini and the D1 mini Pro are identical, also the D1 mini shares the same pin layout. And with the latest board versions of the D1 mini (v4.0.0) vs. D1 mini Pro (v2.0.0) Wemos keeps the pin layout compatible.

Pin	Function	ESP-8266 Pin
TX	TXD	TXD
RX	RXD	RXD
A0	Analog input, max 3.2V	A0
D0	IO	GPIO16
D1	IO, SCL	GPIO5
D2	IO, SDA	GPIO4
D3	IO, 10k Pull-up	GPIO0
D4	IO, 10k Pull-up, BUILTIN_LED	GPIO2
D5	IO, SCK	GPIO14
D6	IO, MISO	GPIO12
D7	IO, MOSI	GPIO13
D8	IO, 10k Pull-down, SS	GPIO15
G	Ground	GND
5V	5V	–
3V3	3.3V	3.3V
RST	Reset	RST

Important: all of the IO pins run at 3.3V.

Source: https://www.wemos.cc

D1 mini vs. D1 mini Pro

The most obvious visible difference between the two boards is the color. In previous versions all boards used a blue PCB, but with the latest release the Pro version got a green PCB.

While the board shares the same pinout, USB-C connector and the LOLIN I2C Port they have a few technical differences. One is the ceramic antenna and the external antenna connector on the board. With the ceramic antenna the D1 mini Pro should have better WiFi reception than its little brother. The Pro board also comes with an external antenna connector to connect a U.FL connector compatible with 2.4GHz Wi-Fi antennas. Projects using the Pro board can also be powered with lithium batteries. The board includes a charging interface with 500mA Max charging current. Another difference is the flash memory size. In comparison, the D1 mini Pro has 16 MBytes of flash memory whereas the D1 mini only has 4 MBytes.

Depending on the projects you build these differences matter for now. It was perfectly fine to use the D1 mini for most of the projects I built.

D1 mini compatible shields

Wemos provides a wide range of pre-build extension shields for the D1 minis. There is a wide range of LED, OLED, TFT and ePager display boards for interactive projects.

Various types of environmental sensors are available. You can choose from simple temperature & humidity sensors, air quality sensors or a standard PIR sensor. Next to the sensor shields Wemos also has a selection of motor driver shields for different areas of applications.

If you can’t find a suitable shield for your project, Wemos offers so-called base shields. These are empty prototyping boards for your DIY projects. They are available in different form factors (1x, 2x & 3x) and can also be used to stack other shields.

All shield boards typically come with male and female pins are already included in the package. A full list of official shields can be found on the Wemos Wiki.

ESPHome & the D1 mini boards

ESPHome works on top of PlatformIO which has support for a wide range of ESP8266, ESP32 and various other development boards. Wemos D1 boars are supported as well, to use them in your ESPHome projects use:

esphome:
  platform: ESP8266
  board: d1_mini

---- or ----

esphome:
  platform: ESP8266
  board: d1_mini_pro

Or use the short form:

esp8266:
 board: d1_mini_pro

I recommend to always use the Wemos specific board name instead of a generic esp board or board: nodemcuv2. While these might work as well the pin mapping might be mixed up and you will get unexpected behaviour.

Green grass with Home Assistant

2022-06-01T00:00:00Z

Home Assistant controlled garden watering part 2 - are you ready?

In my previous post, I explained how I measured the level of water in our garden cistern using ESPHome. In this post, I will describe how the garden watering system works. I will explain how we get our water from the tank, distribute it in our garden, and control the main pump. In addition, I will give an example of how I use the measurements to automatically refill the water tank when the weather is dry.

Garden watering

The only water supply for the entire irrigation system is our water tank. The pipes are not connected to our domestic water connection. There are two reasons for this:

the outside water tap does not have enough pressure and the flow rate is too low
it is cumbersome to connect two water sources - domestic water connection and rainwater tank into one cycle

In our region, connecting domestic water and rainwater can be tricky and may require the installation of expensive extra equipment. A special pump and a backflow stop valve are needed to make sure rainwater for the water tank does not flow back into the public water pipes.

The low flow rate of domestic water connection is a smaller problem and can be worked around by separating the sprinklers into more independent zones. They can be activated sequentially one after each other - will work but extend the overall watering time.

Reliable, robust and without drama

After some market research, we decided to proceed with a commercial product and installed a Hunter Hydrawise Pro-HC 6 in 2020. We have the outdoor version, installed at the back of our carport and currently use 4 watering zones:

complete lawn sprinklers
plants back yard
plants front yard
cypress hedge

To distribute water to the sprinklers and for watering plants, 3/4-inch pipes are used. For the plants we already had a Gardena drip system installed. But we had to control this manually and always connect a garden hose. That is now a thing of the past. The drip system could be connected without any problems to the solenoid valves. The hedge is easily hydrated via some drip hose, which is connected to its own solenoid valve as well.

Hunter Hydrawise controller in our garden house

The Hydrawise Pro-HC 6 can handle 6 independent zones, so there is some reserve capacity for later. The same controller is also available with 12 or 24 valve stations. We also connected a rain sensor to automatically suspend the irrigation as soon as the moisture limit is reached.

I know there are other commercial or open source based solutions and DIY irrigation controller projects but I’m pretty happy with our choice. The Hydrawise Pro-HC in combination with the Hunter solenoid valves is super solid. So far I have had no issues with the Hydrawise controller at all. It simply does the job. Once the zones and schedules are programmed there is no need to touch the system anymore. All this setup can be done with the Hydrawise App. The device also has a small touch display which I really don’t use much. Only during the initial setup and 2-3 times a year if I manually switch a zone but don’t have my mobile around.

The Hunter valves work without any problems. They survived two frosty winters without suffering any damage from the long days with minus degrees.

Hydrawise & Home Assistant

To start the irrigation we need water from our water tank and this is where Home Assistant comes into the picture.

As mentioned above, our water tank supplies the entire garden with water. To get water into all the pipes we have a normal pump. This pump must be manually turned on/off when the scheduled irrigation programs start or end. The Hydrawise Pro-HC 6 actually has 7 valve controls, one additional for the main valve. This one is automatically switched with every zone value switched on or off. But since our 10-year-old pump has no automatic on/off control, it must be operated manually. The main valve will not work here.

However, there is a super simple alternative … we already have a smart home automation system, right? Can we use Home Assistant for that? Yes, we can.

Home Assistant has an integration for Hunter Hydrawise and we can make use of that. It provides sensors & binary sensors for each zone, valve states, current watering time and schedule programs.

With a simple automation triggered by every valve change we can control our main pump:

---
# Switch on/of water tank pump on when Hydrawise irrigation programs trigger.
#
id: 493a7766-2d4f-4f11-a80d-413d02f2498e
alias: '[Watertank] Pump operation controller'
trigger:
 - platform: state
   entity_id:
    - binary_sensor.rasen_watering
    - binary_sensor.vorgarten_watering
    - binary_sensor.beete_watering
    - binary_sensor.hecke_watering
mode: parallel
action:
 - choose:
    - conditions:
       - condition: template
         value_template: "false"
      sequence:
       - service: switch.turn_on
         data:
          entity_id: switch.garden_watertank_pump
       - service: notify.mobile_app_iphone
         data:
          title: JaMa Villa - 🚰
          message: Bewässerung wurde eingeschaltet.
          data:
           group: notification-irrigation
   default:
    - service: switch.turn_off
      data:
       entity_id: switch.garden_watertank_pump
    - service: notify.mobile_app_iphone
      data:
       title: JaMa Villa - 🚰
       message: Bewässerung wurde ausgeschaltet.
       data:
        group: notification-irrigation

I also created a handy dashboard in Home Assistant which shows me the running irrigation program and the next scheduled watering times. Additionally, it shows how much water we have in our tank and how the pump is performing.

Garden watering dashboard in Home Assistant

(free) re-fill

As explained earlier, we get all the irrigation water from the water tank. Our cistern isn’t super large only 5.500 litres. Depending on how often we water and which zones we water, this can run out in 2-3 weeks already.

So … what happens if we haven’t had any rain for several weeks and the tank is empty?

To solve that problem I built a simple but robust DIY re-fill system. First challenge: how to get fresh water into the tank? Our cistern is connected to the gutters of the house and the carport. Rainwater is collected and guided into the tank already. This is the free re-fill we get. So a pipe was already there let’s use that. I connected the outside water faucet to the gutter with a garden hose via a solenoid valve. When the valve is opened, water flows directly into the cistern. That is it, as simple as that.

The solenoid valve is connected via some Sonoff socket which can be controlled via Home Assistant. With a simple automation and the water level data from our ESPHome sensor from part 1 we can start a refill if we are running out of water.

---
# Controll the refill mechanism for the watertank.
#
# If the water tank is below 2500 liter it will be refilled
# via the mains water supply for one hour. This should add ~ 1.400 liter.
# To not irritate the leak detection the refill is paused every 20 min.
#
id: 86e7306b-00ae-4773-9af8-595a1a748858
alias: '[Watertank] Automatic Refill'
trigger:
 - platform: numeric_state
   entity_id: sensor.garden_watertank_liter
   below: 2500

action:
 # first run
 - service: switch.turn_on
   entity_id: switch.garden_watertank_refill
 - delay: 20:00
 - service: switch.turn_off
   entity_id: switch.garden_watertank_refill

 # second run
 - delay: 1:00
 - service: switch.turn_on
   entity_id: switch.garden_watertank_refill
 - delay: 20:00
 - service: switch.turn_off
   entity_id: switch.garden_watertank_refill

 # third run
 - delay: 1:00
 - service: switch.turn_on
   entity_id: switch.garden_watertank_refill
 - delay: 20:00
 - service: switch.turn_off
   entity_id: switch.garden_watertank_refill

Automation appears to be more complicated than it actually is. If we run below 2.500 litres, it starts the refill. It runs for one hour but at 20-minute intervals. This is in our case needed because our domestic water connection has a leak detection system. If an excessive flow or too long water consumption is detected the main tap is blocked. This has to be unblocked manually. To avoid this we simply add some pauses to the automation.

My automation does not consider weather or rain forecasts. With the low flow rate of our outside faucet we get ~1.400 litre of water filled into the tank within one hour. There is enough capacity left if it starts raining a little later.

Summary

Overall I’m very happy with my setup. I finally got the water tank sensor to work with ESPHome after tinkering around with it. The watering controller does a solid job and Home Assistant controlled refill works smooth.

Water tank monitoring with ESPHome

2022-04-02T00:00:00Z

Watering your lawn and plants around the house wasn’t one of my favourite things to do. Especially when we bought a robot lawnmower, watering the lawn became quite a hassle since we had to always put away the sprinklers and hoses after each irrigation.

An automatic irrigation system was needed. Inspired by this thread on the HA Community I started looking into building a DIY solution. Which includes controlling the individual irrigation zones, monitoring the water level of the cistern and, if necessary, automatically filling the cistern. We end up with a mixed setup using a Hunter Hydrawise as the irrigation controller and a custom-made solution to monitor and refill the water tank.

I’m splitting this into two posts. Part 1 is about the ESPHome solution to monitor the water level of our garden cistern. Part 2 will cover the Home Assistant integration of Hydrawise, valves, the ESPHome water tank sensor and automations for the entire garden irrigation setup.

The cistern plays a central role in our garden irrigation. Since the pump can deliver a higher pressure than the house water connection, the entire system is connected to it. For us, no water in the cistern means no watering of the plants or the lawn.

A few tries to get it right

I’ve been working for quite a while on a simple & reliable monitoring solution for our garden cistern. Today’s ESPHome base solution is the 3rd and most stable iteration.

The way the sensor works is very simple. The ultrasonic sensor is mounted inside the cistern above the water. It measures the distance to the water surface. The higher the water level, the smaller the distance between the water and the sensor. When we consume water, the water surface sinks and the distance increases. If it rains or we manually refill the cistern, the distance decreases again. I measured the full and empty levels of our cistern and can interpolate the intermediates. Using a volume formula, I can convert the distance (in cm) to litres.

Schematic drawing of our cistern with pump and sensor placement

This concept is still used for the current version of the water level sensor.

The first version of my cistern water level sensor consisted of a particle.io Photon microcontroller chip, a HC-SR04 ultrasonic sensor, a rechargeable battery incl. charging controller, all together in a waterproof enclosure. I was already familiar with Arduino microcontrollers, so programming the Photon chip was not a problem. The initial version of the source code is available GitHub. Looks super complicated because of the extra logic for average measurement calculation, deep sleep mode and sending the values to MQTT and the particle.io cloud in parallel.

The two main problems of this setup were the Wifi connectivity and the battery management. Since the cistern is completely underground and made of reinforced concrete there is no good wifi coverage inside. Getting a wifi connection required usually 3-5 retries. This drained the battery a lot. To get a long battery life I put the Photon chip into sleep mode most of the time. It took a distance reading every 15 minutes, compared it with the previous measurement and only connected to wifi to send and update if there are any changes. This could mean I did not get an updated measurement for some days and could not be sure that the battery was still charged.

The second iteration was also based on the Photon microcontroller chip. But this time I split the hardware into two units. The sensor box was still inside the water tank. In fact, the microcontroller was now outside, connected to a sensor via cables, and powered by a USB adapter permanently. This setup had way better reliability and no wifi connection problems.

Unfortunately, the HC-SR04 ultrasonic sensor still caused problems. It is simply not made to be placed in a cistern with permanent moisture around.

All good things come in three

After two HC-SR04 ultrasonic sensors died because of corrosion, I began looking for an alternative. For the third and hopefully the final version of the water tank sensor two changes has been implemented:

the sensor device got a waterproof upgrade to a JSN SR04T ultrasonic sensor
the microcontroller was changed to an ESP8266 based Wemos D1 mini pro running ESPHome

So far the JSN SR04T ultrasonic sensor is pretty reliable. The setup has been running super stable for more than a year now.

Photo of Wemo D1 microcontroller

The hardware setup for the water tank sensor is simple. JSN SR04T is connected via the helper module to the Wemos D1 mini microcontroller. Only 4 pins are required: 5V, GND, Trigger pin and echo pin.

Wiring diagram of water tank sensor setup

No further electronic components are required. The setup is powered by a USB power adapter.

watertank-sensor.yaml

If you are not familiar with ESPHome getting started is not complicated, especially if you already use Home Assistant and the step-by-step install guide.

The ESPHome configuration for the water tank sensor is relatively simple. Only 80 lines of YAML config … and these already include the setup boilerplate and some comments.

esphome:
 name: watertank
 platform: ESP8266
 board: d1_mini_pro

wifi:
 ssid: !secret esphome_wifi_ssid
 password: !secret esphome_wifi_password

 ap:
  ssid: esp01

captive_portal:

logger:

api:
 password: !secret esphome_api_password

ota:
 password: !secret esphome_ota_password

sensor:
 # Wifi signal sensor.
 - platform: wifi_signal
   name: garden_watertank_wifi
   update_interval: 600s
   unit_of_measurement: '%'
   filters:
    - lambda: |-
       if (x <= -100) {
         return 0;
       } else {
         if (x >= -50) {
           return 100;
         } else {
           return 2 * (x + 100);
         }
       }

 # Templates for calculated liter & percent
 - platform: template
   name: garden_watertank_liter
   id: garden_watertank_liter
   icon: 'mdi:water'
   unit_of_measurement: 'l'
   accuracy_decimals: 0

 - platform: template
   name: garden_watertank_percent
   id: garden_watertank_percent
   icon: 'mdi:water-percent'
   unit_of_measurement: '%'

 # The actual distance sensor
 - platform: ultrasonic
   trigger_pin: D1
   echo_pin: D2
   name: garden_watertank_distance
   update_interval: 600s
   pulse_time: 50us
   filters:
    - filter_out: nan
    - median:
       window_size: 7
       send_every: 4
       send_first_at: 3
    - calibrate_linear:
       - 0.23 -> 1.86
       - 2.41 -> 0.0
   on_value:
    then:
     - sensor.template.publish:
        id: garden_watertank_liter
        state: !lambda 'return x * 3141.592653589793238;'

     - sensor.template.publish:
        id: garden_watertank_percent
        state: !lambda 'return x * 53.979255216319471;'

The most crucial parts of the code config start in line 56 with the setup of the ultrasonic sensor.

I decided to send updated measurements every 10 minutes only. The water level does not vary that much during most of the year, so there are few updates. But if we consume water quickly and there is heavy rain filling the cistern the 10 minutes interval still results in a smooth graph.

All sensor readings returned by platform: ultrasonic are in meter. This is important for the formulas. Values you put in the formula must be in meters too.

The measuring and calculation of litre and percent happens in two steps. In a first step some filters are applied to the measured distance values to filter out invalid readings and get a smooth median value. All sensor values are in meters, conversion to inches require some extra conversion step.

Since the sensor measures the distance between sensor and water surface it must be transformed into the actual height of the water within our cistern. This happens via calibrate_linear filter. It is used to adjusted and map the sensor values. This filter must be adjusted for your water tank. You need the sensor readings for a full and empty water tank. In my case the sensor is placed 0,23 meter above the water level which translates to 1,86 meter high water level from the ground of the tank. For an empty tank I get 2,41 meter as reading from the sensor. Have in mind that the filter, as the name calibrate_linear says does a linear value mapping, see docs for details.

The values for litre and percent are calculated based on the water height using two lambda functions. The magic factors in the formulas are multiplied out factors for volume of our cistern.

In our case the cistern is a round cylinder, the volume formula for that is:

V = π * radius² * height

With height = x in the lambda function. The diameter of the cistern is exactly 2 meters, hence a radius of 1 meter. To formula for me is π * 1² * x which will return the volume in square meters. That multiplied by 1000 results in the returned value in litres.

The percentage calculation is similar. It is based on the max volume of your cistern, 5.500 litre in our case.

p = π * radius² * height * 1000 / max litre * 100

Is it accurate?

The way the sensor works it cannot be super accurate and it is not really important for our use case but let’s check. I’m comparing the measurements with an older flow meter I had lying around:

Compare watering sensor data with flow meter

The readings from the distance sensor are in centimetres. The minimum change it recognizes is 1cm. If we put that into our formula (in meters) π * 1² * 0,01 we get 0,03141m³ which is ~ 31 litre. That is the minimum accuracy we can get.

Into Home Assistant

To use the water tank sensor in Home Assistant I use the ESPHome integration. Setup is super easy via the UI and all exposed sensor data from the ESPHome sketch is automatically available in Home Assistant.

Screenshot of ESPHome sensor in Home Assistant

In the next post I will explain how the water tank data of the ESPHome sensor is used in Home Assistant. The automations I have set up to control the water tank pump & Hydrawise irrigation controller for the garden and lawn watering.

Hero image photo by Daniel van den Berg on Unsplash

Arlo Cameras in Home Assistant

2022-03-14T00:00:00Z

Home Assistant & Arlo cameras go better together than I initially expected. I’m using it since our entire setup got migrated from OpenHab to Home Assistant and I’m happy with the setup.

But let’s start from the beginning …

How it started

In 2016 I tough about the topic of home surveillance for the first time. I was looking for a camera system that could operate on batteries. I have identified two places at our house where I would like to mount a camera but where there is no electricity or wired network available.

The first time I became aware of Arlo was mid 2016. Back then it was a brand of Netgear, later in 2018 it became its own company Arlo Technologies.

After some quick market research it turned out I didn’t have many options. At that time there was not a wide range of waterproof outdoor cameras available. Unlike today Ring, Reolink, Wyze or Nest cameras didn’t even exist at the time, at least not in Europe.

So Arlo cameras became my first choice and still are today. The initial setup for our home consists of the hub and 2 Arlo cameras - the original version. Later I added a third one.

Arlo cameras, at least if operated solely on batteries, are mostly passive. They only record if someone or something moves. The built-in motion sensor recognises movement and triggers the recording. This helps to optimise for a longer battery life. The initial camera version used replaceable batteries only. These used to last for ~3 months, depending how often the camera got activated.

Later versions of the camera came with a rechargeable battery and could be charged without having to remove the battery. They also can get permanent power from a USB power adapter or charged by a solar panel.

Today our setup consists of two Arlo Pro 2 and three Arlo Pro 3 cameras. When upgrading to the Pro 3 I also replaced the original hub with a new one. Most likely it will remain the same. We don’t need indoor cameras and other devices like a doorbell. Also the service plan I’m currently on, called “Arlo Smart Premier Multi Camera” only allows for up to 5 cameras. One of the cameras is operated with a permanent power connection and two got a solar panel installed. I only have to charge the battery regularly with two of the cameras which still run on battery power only.

Subscription or not

In my view an Arlo system can only be operated properly with a subscription plan - a paid subscription plan. The recordings and video history are stored in the cloud, which will result in storage and streaming costs.

At the very beginning the initial subscription plans still included 7 day recording history stored in the cloud in the free plan. As of 2021, subscription plans changed, so one can only gain access to all features and store recording history on a paid subscription plan.

It is possible to operate an Arlo setup with a “no plan” option. With this you only get live video streaming directly from the camera and basic notifications. It is also possible to store the recordings on a USB stick connected to the Arlo Hub. Overall the free no plan option is very limited. Many of the new features recently added require a paid subscription. For example:

person, vehicle, package and animal detection
advanced push notifications
activity zones and blind zones
theft protection

For me, detecting people, animals, and cars works well. However, I can only really use it for the front door camera. We usually don’t have cars or buses in our garden. With advanced or rich push notifications you get a preview image embedded in the notification and you can directly start the video stream.
Activity zones and blind zones are working ok but not perfect for our setup. They definitely require some tuning. I have defined a few blind spots but still, get alerts for motions in these zones from time to time.

Arlo cameras have a decent price tag. A $249 camera plus pay for a subscription is a bold call. Arlo’s subscription plans are its biggest disadvantage. If you don’t want to pay monthly fees, Arlo isn’t for you and other vendors might be a better fit.

Arlo & Home Assistant

One reason, among others, to switch from OpenHab to Home Assistant for me was the missing integration with the Arlo system. And looking back on it, the Arlo & Home Assistant integration was a little challenge at the beginning. Home Assistant comes with an Arlo integration out of the box. Unfortunately, it looks like it does not get much attention and love. It has had only a few updates lately, mostly catching up with changes in Home Assistant.

Luckily for us, there is an alternative: aarlo - Asynchronous Arlo. It can be used as a replacement original Arlo component and is actively maintained. I work with all Arlo devices, including cameras, base stations, sirens, doorbells, and lights.

Installation

Since AArlo is a custom component it must be installed separately. The easiest way to do this is using HACS. AArlo is part of the default HACS store.

Once downloaded the config is like:

aarlo:
 username: !secret arlo_username
 password: !secret arlo_password

If you want to play with the lasted, unreleased code a manual deployment, directly from GitHub is possible as well.

The setup in Home Assistant is pretty simple. For the default setup you provided an Arlo username and password. It is highly recommended to create a dedicated Arlo user account for Home Assistant. Don’t use your main login you use on your phone. Otherwise, you will constantly get logged out, looks like Arlo does only accept one login for a user at a time.

If you have Arlo 2FA enabled enabled - which should be standard nowadays, some extra config steps are needed. Make sure you configure with the correct 2FA method - IMAP or PUSH - for your Arlo account.

Component Configuration

After creating the Arlo login you can continue to set up the components. We get many different components and sensors with the AArlo integration. Some of them depend on the devices you own and also on the subscription plan.

In my setup, I use the camera component as an obvious part of a camera surveillance solution, along with the alarm component and some sensors. The configuration and how it is used in my setup is described below.

Additionally, AArlo provides a comprehensive collection of sensors, binary sensors, switches and lights and media_player for your Arlo devices. For these check the documentation on Github:

First and most important the camera:

camera:
 - platform: aarlo

That is all you need, AArlo will create a camera.aarlo_xyz entity for each Arlo camera in your account. The naming pattern for all entities created by AArlo is component-type.aarlo lowercase name with underscores. Sensors will use the same naming convention as well.

AArlo is very verbose cameras and sensors have a lot of detailed information and attributes. All camera & device details, configuration information, battery & charging details, environment sensors and last recordings and image snapshots are available.

The following Home Assistant sensors are available:

sensor:
 - platform: aarlo
   monitored_conditions:
    - total_cameras
    - last_capture
    - recent_activity
    - captured_today
    - battery_level
    - signal_strength
    - temperature
    - humidity
    - air_quality

While total_cameras is a global sensor showing the number of configured devices all other sensors are created for each device. Not all sensors will be available for all devices, for example, my cameras (Pro 2 & 3) don’t provide temperature, humidity or air quality information.

Especially last_capture is interesting here, it provides many details on the last recording. The sensor includes thumbnail_url & video_url containing the secure URL to directly to the thumbnail and video recording on the cloud servers. This is very handy if you want to use that for some automations. If smart object detection is set up this sensor has two additional attributes. object_type contains the detected object like “person” or “vehicle” and object_region has the rectangle coordinates of the detected object within the image.

Camera Services

The AArlo component provides a set of Home Assistant services to control the cameras, set the alarm modes or trigger alarms.

I mainly use them to start a recording (aarlo.camera_start_recording) or request an image snapshot (aarlo.camera_request_snapshot) within automations.

Custom Lovelace Card

Additionally, AArlo also comes with a nice custom lovelace card. The card is optional, the standard picture-glance or other cards can be used as well. I like that card very much because it has a bunch of extra functions tightly integrated with AArlo.

It has very powerful options for individual setups, can be configured for one or multiple cameras and allows direct access to the camera library recordings. Users can directly interact with the cameras to start recording, stream live video, or take a snapshot.

My usage of the cart is pretty standard:

- type: 'custom:aarlo-glance'
  entity: camera.aarlo_pool
  image_top:
   - name
   - date
  image_bottom:
   - motion
   - library
   - stream
   - snapshot
   - battery

The result looks like:

The library view looks like:

Notice the rectangles for the detected persons or animals.

Additional details on motion and sound notification sensors can be displayed as well. For doorbells, the card provides extra functionality like door opening notifications.

A good combination

For my situation the Arlo & Home Assistant combination is a good fit. Using them together gives me a solid security camera solution that I can use with the automation power of Home Assistant.

Yes, they are expensive, especially when we consider the subscription plan as well. I’ve been looking for alternatives time and time again in the past. I even ordered some Reolink and Blink, but all were returned back. Still, in 2022 there are not many reliable alternatives for battery-powered camera systems. I still recommend Arlo if battery power is a requirement.

Mia's Dino Facts

2022-02-06T00:00:00Z

My daughter Mia is a huge dinosaur fan, almost a little dinosaur nerd. We are overwhelmed with information about dinosaurs every day. It starts during breakfast and doesn’t stop before she falls asleep 😉.

She is super happy when she can share her dinosaur knowledge with someone. Then, between the Christmas holidays last year, we had the idea: how about sharing the Dino knowledge not only with family and friends but with the whole world.

This was the birth of dino-fakten.de - her very first website.

One more dinosaur website

Yes, there are plenty of sources of information about dinosaurs and some good websites about them, but why another?

With her own website, Mia can present her personal dinosaur knowledge to the whole world. Formulated and processed as she imagines, her little 🦖 corner on the internet. The Dino Facts on her website are organized with what she calls “card”. Each dinosaur gets its own page with all the facts and details.

Visitors can look at Mia’s favourite dinosaurs, search for dinosaurs directly and recently I added a map with the localities of the different dinosaurs around the world.

Some technical details

The website was built with Eleventy, just like my own blog here. Since I’m not a web design professional, I just looked through the list of Eleventy starters with Mia. There we found My Online Cookbook, created by Maël Brunet. Actually, as the name suggests, it is made for online cookbooks and recipes. Mia liked it and so we repurposed it a bit.

The starter template was already prepared to work with Netlify CMS - a simple CMS UI built on top of markdown files in a Git repository. This was super helpful for us. I didn’t want my daughter learning and playing around with Markdown files. A mini CMS is exactly the right thing here. She was able to start and enter dino content while I was still working on the website. Meanwhile, after getting used to the editor, markdown is no longer a problem either. I’ve observed her every now and then she switches from rich text editor to markdown to type in her dinosaur descriptions.

On the technical side of things, the template was built around SASS for CSS processing and Alpine.JS for interactions, such as search, on the website. This was a good foundation for the world map I added using the DataMaps library.

The site itself is now hosted on Netlify, with the domain managed by all-inkl.com.

The source code of the site is available on GitHub:

What is next?

With the site online and the CMS setup, the main technical work is done. I leave the responsibility for the website more and more to Mia. She created fact sheets for 25 dinosaurs and is constantly adding more every week.
She also already has some other content ideas: dinosaurs in Minecraft (her other hobby) or report about our trips to dino parks.

And my favourite dinosaur … that is the Triceratops.

Website History

2022-01-20T00:00:00Z

In this post I will briefly describe my personal website’s history. It started in 1998. At this point, I have already gone through six iterations. I had already completely forgotten two of them.

My personal blog is built around simple HTML and CSS. There’s no need for much javascript on the site - something I got sorted out over time. The site also become a bit of a playground.

Described here is a brief explanation of the evolution steps and the tools and technologies behind each version.

V1 - Geocities

On May 1st, 1998 the first version of my personal website was put online on Geocities. Geocities does not exist anymore nor does my own website, the old URL is not available anymore.

I don’t even remember exactly what the site was about and what content I put there.

V2 - www.markus-haack.de

On December 12th, 1999 I registered my first domain markus-haack.de at NetBeat. Initially, it was just a HTML frameset embedding the Geocities site. “frameset” is not used anymore these days, it was only available till HTML 4.

A few weeks later I rebuild the site with Dreamweaver, all static HTML with some basic CSS and Javascript. It was the first time I dipped my toe in the cold water of web development.

V3 - blogger.com

In October 2004, after the site was in deep sleep for a while, the first blog “Klasse Kaffee” was launched on blogger.com platform. And I started posting more frequently.

V4 - Wordpress

On 19. December 2005 I announced the move of “Klasse Kaffee” to my own hosted space. This was the time at which I gained my first experience with Wordpress 1. The initial theme of the site was called MX4. In 2006 the site was upgraded to Wordpress 2.0. Also, this version is available in the Internet Archive.

I blogged regularly until 2010, after which I lost interest a little.

V5 - Gatsby

How the time flies … In 2019, 9 years later, I reactivated the domain and started blocking again. It was a fresh start. The entire site was rebuilt with React from scratch using Gatsby using the Stellar theme. A snapshot is still available in the Internet Archive.

The redesigned blog also got a new markus-haack.com domain. The .de domain markus-haack.de still exists, it redirects to the .com domain.

I started writing in English, which was something I had never done on my blog before. I mostly write about smart home and IoT (Internet of Things) projects I have built. I also post professional news occasionally.

Later in 2019, I switched the theme to Novela which was, back then, actively maintained and updated.

V6 - Eleventy

The most recent framework I have adopted is Eleventy. Eleventy fulfils a similar task as Gatsby and is also implemented in Javascript.

There is one big difference between the two tools: even a site without any JS, or that is entirely server-side rendered, will still ship a bunch amount of client-side JS to make it feel “lightning fast”. It seems logical to only send JS to the client when it’s actually needed, so for a simple static site, like this blog it’s unnecessary. That’s why Eleventy seems like the better choice.

Getting started with Eleventy was pretty easy. The documentation is excellent and there are plenty of how-to guides like this one.

The initial template I used was the Eleventy Duo theme. While it helped me get the site up and running, I added quite a few extensions and customizations. As the site got more and more complex, I re-wrote the entire CSS to Tailwind CSS and little remains of the original template.

Source hero image: unsplash.com

CIF on Adobe Tech Blog

2021-12-11T00:00:00Z

In the last few weeks and months, my colleagues and I have written several articles for the Adobe Tech Blog. Since I am also presenting some of my professional projects here, I wanted to take the opportunity and briefly introduce them.

Taking a Deep Dive into Adobe Experience Manager’s Commerce Integration Framework

This is the first article in a series that we wrote about the Commerce Integration Framework (CIF) - the project I’m current working on most of my time at Adobe.
CIF is a powerful Adobe Experience Manager extension for building integrated and seamless content and e-commerce experiences.

Architecting a Better Ecommerce Experience with Commerce Integration Framework

The second post on CIF explains the high level architecture, cloud-native integration concepts and explains the core elements of the Commerce Integration Framework:

How CIF Integrates with Adobe Commerce and Third-Party Commerce Solutions

The most extensive blog post on CIF so far goes deep and explains the architecture details on how AEM & CIF integration works. It explains the different integration scenarios and options projects can apply to integrate Adobe Experience Manager with Adobe Commerce or third-party commerce solutions.

Building Rich Content and Commerce Experiences with CIF

The 4th blog post is a little context switch. While the first three posts have been all about architecture, infrastructure and integration options, this article is for the business user. We give an overview of the functionality of CIF and explain the individual functions that an AEM author has to create engaging commerce experiences.

Have fun while reading the posts.

New Talk: Extend AEM Content & Commerce

2021-10-18T00:00:00Z

At the last Adobe Developers Live conference I gave a talk about how to extend AEM Content & Commerce with new Adobe Developer App Builder.

In this talk I discuss AEM Commerce integration & extensibility patterns using App Builder. I explain how you can integrate your eCommerce solution, either in house home grown services or an off the shelf commercial solution, with Adobe Experience Manager. The talk covers the overall integration architecture, how we use GraphQL in the Commerce Integration Framework (CIF) and how you can easily build your own integration.

Interested? The recording for my talk is now available on YouTube.

https://www.youtube.com/watch?v=25cTzVV2jfQ

Projects build by our team mentioned in the talk:

Mini plant watering project

2021-08-17T00:00:00Z

I would like to show you my new half 30 minutes no coding holiday Home Assistant project. My daughter’s Mimosa plants need some water while we were on vacation, so I built this super simple automated watering system. The project goal is to keep the plants alive for two weeks while we are away. Nothing permanently only a temporary project.

https://www.youtube.com/watch?v=0LImGXfNvG4

It was built very quick shortly before we went out to our summer vacation place. I only used parts that I already had lying around. It took ~ 30min to build the project.

Parts

The plants 🪴
Water hose
Water bottle, a bucket, or some container
A mini pump
A 5V power supply
A smart socket outlet which can be controlled by Home Assistant
Some wires
Cable ties
Tape

Assembly

Ok there is not much assembly needed for this project, no soldering, no screws, no glue. You can do a lot with cable ties and tape 😀

The little bench for the plants was already there before I only had to mount the little bridge holding water hose. It is fixed with cable ties and locked with two cable ties at the end to prevent the water from leaking. Above the plants I made a tiny hole in it with a small screwdriver. Be careful it should be super small so that the water can slowly drip out.

The aquarium pump can be mounted anywhere. It fixes it directly to the water bottle with cable tiers. Depending how long and how often the irrigation should run you might need a bigger water container. Then connect the water hose to the pump. Almost done.

The pump, in my case, requires 6 volts. I had this old power supply that can deliver 5 volts, enough to run the pump for a few seconds. The wires from the pump are connected to the plug at the end of the power supply cable and fixed with some tape. Pay attention to the correct polarity. Ok not very professional but it works, and it is low voltage only so it will not burn down our house.

The last step is to connect the power supply with some smart socket which can be controlled by Home Assistant. I use a Sonoff S20 which I have left from another project. It is already flashed with Tasmota firmware which works perfectly with Home Assistant. I just had to rename the device. Other controllable socket outlets like a Shelly Plug S will work as well. The socket should be connected to you Wifi network, if not already done before.

Place the plants directly under the holes in the hose and put some water into the bottle. Maybe also have a towel at hand in case something goes next to the flowerpot.

And now - it is time for the first “dry-run”.

Home Assistant

First why do you need Home Assistant here? The answer is you don’t. But it makes the project so much easier. Even the job for Home Assistant for this project is only on simple task: switch on/off the pump at a scheduled time. This can all be done by having a timer on the smart outlet directly (both Tasmota & Shelly firmware can do this) or by using a micro controller with a relay.

Doing this with Home Assistant is simple and fun, plus you get the user interface and app to control the socket manually for free. You get logs and events when and how often the pump runs. And with Home Assistant & Nabu Casa you get access to your plant watering from everywhere in the world - that’s cool.

The first step in HA is to add the controllable socket via the Home Assistant integration page. Depending on the device it might be already automatically discovered by Home Assistant. Since I reuse a Sonoff S20 I had used before I just did some double check.

This is the Sonoff device for other integrations this should look similar.

In a second step I created a simple automatic rule to switch on and off the pump. The automation was created entirely in Home Assistant UI.

It is super simple: it runs a a fixed time, not every day, switch on the Sonoff socket to enable the pump, wait 5 seconds and switch off the pump again. The wait time must be adjusted to the amount of water needed by your plants.

Here is the full YAML for reference (id and device_id’s will be different) :

- id: 1394083d-7c2f-4a3f-8690-59a691148bcx
  alias: '[Childsroom] Mimosen gießen'
  mode: single
  trigger:
   - platform: time
     at: 07:00
  condition:
   - condition: time
     weekday:
      - mon
      - wed
      - sat
  action:
   - type: turn_on
     device_id: 6788c5632346427ca0e4b7aa21e271dc
     entity_id: switch.sonoff_nursery_watering
     domain: switch
   - delay:
      seconds: 5
   - type: turn_off
     device_id: 6788c5632346427ca0e4b7aa21e271dc
     entity_id: switch.sonoff_nursery_watering
     domain: switch

With that you are good to go on holiday a little longer without hesitation and the plants will survive.

AEM's Headless Extension for Adobe Commerce PWA Studio

2021-06-30T00:00:00Z

Together with my colleague Mark J. Becker I wrote an introduction and instructions on how to use AEM Content Fragments together with the Adobe Commerce (aka. Magento) PWA.

We provide step-by-step instructions that explain the individual tasks in detail, using a blog example - starting with setting up the PWA with the help of PWA Studio, via setting up the GraphQL endpoint in Adobe Experience Manager, managemnet of the content fragment models and content fragments itself and up to deployment.

Check out the full post on the Adobe Tech Blog.

Content and Commerce with Adobe Experience Manager as a Cloud Service

2021-03-04T00:00:00Z

I held a session on “Content and Commerce with Adobe Experience Manager” at the recent Adobe Developers Live | Content conference.

The recording for my talk is now up. If you couldn’t join the session, please watch and learn about how to get started with Commerce on Adobe Experience Manager as a Cloud Service.

Your browser does not support the iframe element.

The slide deck is available as well.

An overview of all sessions and recordings of this two-day conference are available on Adobe Experience League.

Arduino Dollhouse Mini TV

2020-12-13T00:00:00Z

A mini TV for my daughter’s dollhouse

This project and the blog post about it were originally created in February 2019. A few weeks ago I updated the Mini TV software so it was time to update the blog post as well.

The dollhouse Mini TV is a small Arduino project using an ESP8266 chip on a Wemos D1 board and an SSD1306 OLED display to build a small working TV for my daughter’s birthday. She already had this older plastic TV showing some yellowed picture and the project brings that TV to life.

The TV displays an endless loop of different TV “channels” showing animations, a clock, and a weather forecast. With a small button at the side, one could stop the loop and watch the current channel. Another button press continues the loop.

From prototype to working mini TV

The display size for this project was predefined by the frame size of the old dollhouse TV. There were only a few options and I had an SSD1306 OLED display laying around. A normal NodeMCU or Adafruit feather was too big for the small frame, so I decided on a Wemos D1 which fitted nicely into the old TV.

The TV is powered via dollhouse cabling. All rooms have mini sockets installed providing 4.5 volts, enough to power the mini TV. Only the DC polarity is a small problem for the TV, it needs to be plugged in the correct way.

The display shows 5 screens (can be extended) in a carousel mode. Most of them are little cat or dinosaur animations but it has a real weather forecast and a nice clock as well. Additionally, I added some real black & white pictures of our cats with the last update.

Hardware components & tools

Wemos D1 mini
SSD1306 OLED Display
Tactile Button Switch
Dollhouse plug (fitting into the sockets the dollhouse already has)
USB cable (for programming only)
Some wires
Soldering iron
Hot glue

The wiring is pretty simple the display connects via I2C bus to the Wemos board and the button just needs two wires.

Software

Like some of my other Arduino projects, I used Homie as a base library for this project. This is actually not really necessary for the Mini TV as it has no special requirements and does not need MQTT. But since it uses the same SSD1306 OLED display I could reuse some of the Homie node classes from the mqtt-bme280-homie project.

Additionally, with Homie one gets OTA update as well, which is important here because I hot glued the board to the rear wall of the TV and could not access the USB connector anymore.

The following software libraries are used for this project:

Homie V3 for ESP8266 including dependencies
SSD1306 driver for ESP8266 platform
NTPClient to connect to a time server
ESP8266 Weather Station
PlatformIO environment for building the code

Code structure

As usual, the source code and configuration details can be found on GitHub: https://github.com/mhaack/arduino-dollhouse-tv
It is organized into 4 main modules:

dollhouse-tv.cpp - the main program drawing all the TV screens and assembling them all together
DisplayNode.h / .cpp - generic class to control the SSD1306 display
ButtonNode.h / .cpp - simple and generic class to capture the button press (this is from http://github.com/luebbe Homie node collection)
WeatherStationNode.h / .cpp - Homie wrapper class around the OpenWeatherMap client of the ESP8266 Weather Station project

Additionally, we have WeatherStationFonts.h to store the weather icons like sun, clouds, etc. for the weather display. And images.h which has a list of array constants storing the images & bitmaps.

The TV logic itself is very simple. For each screen aka. channel there is a “draw” method defined in dollhouse-tv.cpp:

void drawCat(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
void drawStars(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
void drawClock(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
void drawWeather(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
void drawDino(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
void drawPictures(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);

Each method is used to draw the channel-specific information or images on the screen. They contain mostly painting method calls and have access to the entire display. For transitions between the different screens the draw method gets virtual x & y coordinate. This is used to have a smooth animation while the current screen is transition in and out.

void drawDino(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) {
    display->setColor(WHITE);
    display->drawXbm(x + dinoPosX, y, dino_width, dino_height, dinoPointers[dinoState]);

    dinoState++;
    if (dinoState >= 16) {
        dinoState = 0;
    }
    dinoPosX++;
    if (dinoPosX > 128) {
        dinoPosX = -64;
    }
}

The above example shows a dinosaur animation build-out of different sprites. It sets the color (there are only white and black on an SSD1306 OLED display) and draws the bitmap image. Then it moves to the next sprite and one pixel to the right on the x coordinates until the dinosaur reaches the edge of the screen.

Configuration

Like all Homie-based projects, this project needs a configuration file as well. To configure the device, you have to create and manually flash the configuration file to the device SPIFFS at the /homie/config.json. The following sample configuration file can be used for upload. This file is in the GitHub repository as well.

{
 "name": "Dollhous TV",
 "device_id": "mqtt-dollhouse-tv",
 "wifi": {
  "ssid": "<wifi ssid>",
  "password": "<wifi password>"
 },
 "mqtt": {
  "host": "<mqtt server hostname or ip>",
  "port": 1883,
  "auth": true, // if MQTT server requieres authentication
  "username": "<mqtt username>",
  "password": "<mqtt password>"
 },
 "ota": {
  "enabled": true
 },
 "settings": {
  "flipScreen": true,
  "WeatherApiKey": "<your open weather map api key",
  "WeatherLanguage": "en",
  "WeatherLocation": "2950159",
  "WeatherUpdate": 15
 }
}

The important configuration settings here are the wifi username & password, the MQTT settings, and the parameters for the OpenWeatherMap client.

For MQTT you need to provide the server’s hostname or IP address. If authentication is used username and password are required here as well. If not you don’t need to include these in your config.

To retrieve OpenWeatherMap weather three configuration parameters are needed:

WeatherApiKey - To load weather data from OpenWeatherMap you need an API key, follow the instructions create one for your needs.
WeatherLanguage - set this to get the output in your language, check here for available languages
WeatherLocation- this is the identifier of the location you want to load the weather data for. To get it open the weather details for the place you are interested in and copy the number of the location from the URL. For example the Berlin OpenWeatherMap page, you take 2950159 from the URL.

As an alternative to the file upload configuration, Homie ESP8266 also allows configuration via HTTP JSON API. Once the device is running and connected individual configuration settings can be changed via MQTT as well.

Your own screens and animations

You can add as many screens as you want and add them to dollhouse-tv.cpp via the setup method. Each screen animation goes into its own “drawXYZ” method, for an animation example see drawCat.

If you want to build animations out of a sequence of XBM bitmaps you can follow the procedure below.

The workflow to add a new image animation is simple. First get the image either as an animated gif or independent image files, ideally in black and white format. The size of the image should match the screen size of the display. For the SSD1306 OLED display it must have a width of 128 pixels and a height of 64 pixels. Gif animations have to be split into individual image files.

These can be converted to an XBM bitmap file using some image tool or an online service like https://convertio.co/gif-xbm/. Put the XBM files into the project src folder or merge them into images.h. After that, they can be loaded into the code by using drawXbm. Make sure you add the x & y coordinates from the method parameters when drawing on the screen to have smooth transitions if the screen is changed to the next one.

That’s it have fun with the Mini TV.

Home Assistant: You have got mail

2020-09-05T00:00:00Z

Today I want to share a little holiday project I build this week: a mailbox sensor to make a dumb mailbox smart and notifying us if we got new mail. I’m talking about real physical mail here - letters, postcards, newspapers etc. dropped into our mailbox.

How does it work?

The project is build using two Xiaomi ZigBee contact sensors I had leftover. You can get these from Gearbest, AliExpress, or Amazon. Our smart home setup already has a ZigBee network running using a Conbee II stick. Of course, it is integrated with Home Assistant already.

This is how the setup looks like:

The hard(ware) part

Not much is needed for this project:

2 ZigBee contact sensors (e.g. Xiaomi…)
ZigBee network (for example via Deconz)
Home Assistant
Duck tape, hot glue, etc. to fix the sensors

The setup depends a little on the construction of the actual mailbox. Ours has a flap on the front side where the mail is thrown in and a door on the backside to empty it. So I needed two sensors, one to detect if the mail was inserted and a second one to detect when we cleared the mailbox. For a mailbox with just one door or flap, only one sensor would be needed. Our mailbox is made of metal, like most mailboxes here, built into a concrete column. I first thought having a metal frame like this might be problematic with the ZigBee signal but that is not the case.

For a first prototype, I just duck taped the sensor inside the mailbox. On the door sensor the original magnet was too small so I replaced it with a bigger one.

This is it for the hardware assembly, actually not really hard.

The fun part

With the hardware part done we can now have a look at the software part. Since our ZigBee network was already running it was easy to connect the two new sensors via the Deconz UI.

With Deconz integrated into Home Assistant the new sensors are immediately available in Home Assistant as well.

No extra configuration is needed here. Just name the sensors are you prefer. Adding some ZigBee sensors to Home Assistant - pretty easy. Additionally to the two deCONZ sensors I use one boolean input helper plus a corresponding template sensor to keep the state of there is mail or not. deCONZ also creates battery level sensors for each battery-powered device. These are not really used here, but there are other automations that notify us of batteries running low. For convenience one more boolean input helper is used to enable/disable the mailbox notifications. In total there are 5 sensors and 2 inputs used for this project.

The last step is to build out the automations. I’m still having all automations in YAML, so the mailbox automations are added here as well. For the mailbox sensor three automations are needed:

set the mailbox state if the mail was inserted
Reset the mailbox state once we have cleared the mailbox
Reminder in case we forgot to empty the mailbox in the evening

All of them are relatively simple and short.

The mail detection automation is executed when the flap of the mailbox has been opened the sensor triggered. It sets the mail state to on and sends a notification. Notifications are only sent if the second condition is also met.

---
alias: '[Mailbox] Mail detection'
trigger:
 - platform: state
   entity_id: binary_sensor.garden_mailbox_flap
   from: 'off'
   to: 'on'
action:
 - service: input_boolean.turn_on
   data:
    entity_id: input_boolean.garden_mailbox
 - condition: state
   entity_id: input_boolean.garden_mailbox_notification
   state: 'on'
 - service: notify.mobile_app_xyz
   data:
    title: JaMa Villa - 📬
    message: Trari, trara, die Post ✉️ ist da!
    data:
     push:
      thread-id: 'ha-mailbox-notification-group'

The mailbox door automation is even simpler. It just resets the mail status to off if the mailbox door got open which is the indication that the mailbox has been emptied.

---
alias: '[Mailbox] Reset'
trigger:
 - platform: state
   entity_id: binary_sensor.garden_mailbox_door
   from: 'off'
   to: 'on'
action:
 - service: input_boolean.turn_off
   data:
    entity_id: input_boolean.garden_mailbox

The reminder automation is also very simple. At a certain time it checks the mailbox state and sends us a reminder in case there is still mail in the mailbox. We decided to have two reminders: first at 6 pm, second at 8 pm.

---
alias: '[Mailbox] Notification'
trigger:
 - platform: time
   at:
    - '18:00:00'
    - '20:00:00'
condition:
 - condition: state
   entity_id: input_boolean.garden_mailbox_notification
   state: 'on'
 - condition: state
   entity_id: input_boolean.garden_mailbox
   state: 'on'
action:
 - service: notify.mobile_app_xzy
   data:
    title: JaMa Villa - 📬
    message: Der Briefkasten wurde noch nicht geleert, da ist noch ✉️ drin.
    data:
     push:
      thread-id: 'ha-mailbox-notification-group'

That is, not much needed for this little fun project.

Source hero image: Flickr - Helgi Halldórsson

Building Experiences - AEM & Magento Commerce Integration

2020-07-31T00:00:00Z

I want to share some professional projects I’m working on: Commerce Integration Framework and the AEM CIF Core Components are built by the team I’m working for at Adobe.

On July 28th I was a guest on Mark Szulc’s Building Experiences using Adobe Experience Cloud show. We discussed how Adobe Experience Manager works together with Magento, using the latest release of the Commerce Integration Framework. I explained how projects can use the power of CIF and how we support AEM as a Cloud Services.

Check out the recording of the live stream:

https://www.youtube.com/watch?v=6LUHYCEx4GU

All our projects are open-source, public on GitHub.

Mark does regular live streams on different interesting topics around Adobe Experience Cloud and Adobe Experience Manager.

Our home sweet smart home

2020-01-14T00:00:00Z

I try to gather and describe our Home Assistant setup here, along with the configuration in GitHub. Maybe there is something useful to copy and adapt 😃 I already documented our migration journey from OpenHab to Home Assistant and some details about how to better integrate Homematic devices into HA.

Overview

Our Home Assistant setup is simple - everything currently runs on a single board Odroid N2. The N2 has only recently replaced the Raspberry Pi 3B. Like may Home Assistant beginners we started with Raspberry Pi (it was used for OpenHab before as well) and were pretty ok with it. Until the SD Card broke, that was a good opportunity to move the entire system to the Odroid N2.

Other main gear we use:

Device / Solution	Usage
Homematic CCU3	Used to control all Homematic devices, mainly security devices like window/door sensors, motion sensors or sirene. Plus a few switch relays for DIN rail mounting.
Phoscon Conbee II	The main ZigBee Hub and second wireless device network. All Ikea & Hue light bulbs und LED stripes are connected to the Conbee ZigBee network. In addition temperature sensors in every room and a few contact sensors, we installed lately.
Arlo	Arlo camera system integration, currently we have 5 outdoor cameras connected. We are early day Arlo users, started with the 1st generation cameras, later we added Arlo Pro 2 devices.
Rademacher DuoFern	Wireless controller for our electric roller shutters. In fact, the roller shutters were the first smart devices in our house installed 5 years ago, long before Home Assistant took over the control.
Ubiquiti UniFi	Our home network is operated by UniFi wired and wireless devices. Router, Switches, Wireless Access Points, … all UniFi. Only the DSL Modem is from DrayTek.

The entire system looks like this:

Dashboards

A small selection of Lovelace views. We use Lovelace in Yaml mode, the main Lovelace config file is found here, and the folder defining the views here.

Main info view

House view

Garden view

System view

Integrations

Like any other Home Assistant setup, we have many integrations. And with every update or new toys I get the list gets longer. The five most important integrates our setup relies on are:

Integration	Config
Homematic	Git
deCONZ	-
Unifi	-
MQTT	Git
AdGuard Home	-
Mobile App	-
Sonos	-

Custom Integrations

While Home Assistant already includes more than 1.500 integrations there are still some devices or services which are not integrated yet. Additionally, there is a large ecosystem of so-called custom integrations. They are not natively integrated into Home Assistant and must be loaded sideways via some special folder. Luckily there is HACS (Home Assistant Community Store) which helps to manage custom integration and Lovelace UI plug-ins, and which is a custom integration on its own.

Custom Integration	Config
aarlo	Git
Rademacher DuoFern	Git
hacs	Git
browser_mod	Git
Miele	-
Waste Collection Schedule	Git

Custom Lovelace cards

To pimp the Lovelace dashboard, we use a bunch of custom lovelace cards. The three most used are:

Custom Card	Documentation / GitHub
Mini Media Player	Docs, Git
Layout Card	Docs, Git

A full list of all custom cards currently used is in Git. Just like the custom integrations, the custom Lovelace cards are managed via hacs.

Hass.io add-ons

The entire JaMa Villa Home Assistant setup is running and managed by hass.io. With the following add-ons currently used:

That’s it on our Home Assistant setup. Feel free to reach out if you have questions.

Home Assistant - Homematic HM-Dis-EP-WM55 e-paper display

2019-07-08T00:00:00Z

Home Assistant

I recently switched from OpenHab to Home Assistant. While this transition was smooth for most of the devices and integrations the Homematic part was a little more challenging.

Homematic is a proprietary Smart Home solution mainly marketed in Germany. It is actually an entire Smart Home ecosystem similar to SmartThings. It can be used as a standalone solution and has a wide variety of devices. OpenHab has extremely good support from Homematic, I think mainly because OpenHab has a big German community and user group.

The HomeMatic integration of Home Assistant has decent support for many Homematic devices as well, but some have special features like remote control or displays that require more work to integrate. Luckily the Home Assistant integration supports communication with a device on the low-level protocol to send any kind of data to any device.

The display

The device I needed to get working with Home Assistant is the wireless e-paper display (HM-Dis-EP-WM55). It is installed on a central place in our house, displaying the status of open/closed windows & doors and our two alarms for the house and garden house.

The display has 5 lines of text and icons, a three-color LED and a beeper. One can configure the text of the first and last line via the Homematic CCU as fixed device parameters. The 3 middle lines can be controlled and updated via some command. The display itself is always on but consumes very little energy since the e-paper display does not need power all the time, only if changed. It also acts as a switch with two buttons which both can trigger a long or short press event.

Home Assistant integration

The HM-Dis-EP-WM55 display can be controlled via a dedicated channel (#3) where you have to send the data in order to update the display content. A special encoded string must be sent to the device to update the text, icons, LED color and beeper, all in one. It is not possible to send partial updates; the string must always contain all information one would like to show on the display.

Since there is no Home Assistant device type for a display the only way to communicate with the HM-Dis-EP-WM55 display is via homematic.set_device_value. This command can be used to send any kind of data to any HomeMatic device integrated with Home Assistant. It is basically a low-level interface to a device. To use it one must know the device-specific behavior and data formats the device understands.

I created some python scripts to concatenate all the text lines, icons, LED color and encode the string and push that to the device.

The scripts are split into two parts:

A generic update_display.py script which does all the encoding and construction of the proprietary string format – this one can be reused directly
A second, custom to my/your setup script to extract the data from my devices, collecting all and sending it to the first script

The update_display.py script constructs the string beginning with the three text lines and icons, encoding special characters, followed by the beeper code and LED color. This is sent to the device homematic.set_device_value.
The second script is included in my automation’s, once called it collects all the device variables and merges all data into a JSON object. Some values like the device id or display text which does not change are hardcoded. This JSON is sent to the first python script.

The button press events (homematic.keypress) can be captured by a simple automation. See Homematic Home Assistant integration for more details.

The full scripts are available in my Home Assistant config repo in the python_scripts folder on GitHub. These are my first python baby steps, feedback and improvements are always welcome.

Home Assistant - The big move

2019-05-21T00:00:00Z

From OpenHab to Home Assistant

This “project” is about the change I did from OpenHab to Home Assistant for our smart home automation system. Ok maybe the headline sounds a bit too sensational but change our entire home automation setup from one system we used for 2+ years now to a completely new one requires quite some heavy lifting.

Let’s start from the beginning. I’m running a smart home system for our house for almost 3 years now. I started with OpenHab 1 and quickly moved to OpenHab 2. I always wanted a system with local control and not cloud connection required, at least not by default. I also wanted to be vendor in-depended and don’t install a ton of apps on my smartphone. So OpenHab was a pretty good choice and already stable solution, they also have a quite large community in Germany and support a few more local system like Homematic which are not known elsewhere. The initial reason why I decided to go with OpenHab was the very good support for the Homematic ecosystem, maybe the best you can get at the moment.

So why change a running system?

Maybe 6 months ago I decided to move the smart home controller from OpenHab to Home Assistant. So why looking for an alternative? I was dissatisfied with the overall situation of OpenHab. This is not bashing on OpenHab, this is only about my personal opinion and view on it - which changed over time. Both systems are very powerful home automatic systems with a ton of integrations and both fulfill my requirement of being local and cloud independent.

This was actually the 3rd time I looked into Home Assistant, two times I put it away and decided to stay with OpenHab. I finally decided now is the time for something new because I’m not happy with OpenHab process anymore. OpenHab moves slowly with yearly major releases (I know there are milestones now as well) and the core team spends very much time to keep the platform stable while continue to improve it. But there is not so much improvement on the integration side. While I was happy with how Homematic, Hue, Sonos, etc. are integrated other devices we have like Rademacher, Roomba or Ubiquiti took a very long time or are not available.
Home Assistant, on the other hand, moves very quickly, they have a release every 2-3 weeks, adding new integrations with every minor release while fixing bugs and improving the core - pretty impressive pace. All except one (Landroid) integrations I was looking for are available for Home Assistant and also the Homematic integration has improved a lot (compared to when I looked at HA the first time).

A new smart home automation system

The old system was running on a RaspberryPI and for Home Assistant I keep it like that. The hass.io installer is a great help, the new system was up and running in minutes. Hass.io also has a large collection of add-ons. Installing other core services in I need like Mosquitto, InfluxDB or Grafana was just a few clicks.
Many of Home Assistant users run the system and bigger machines like Intel NUC maybe I will upgrade sometime later for now I’m fine with the RaspberryPI.

My current setup looks like the following:

Moving over my environment from OpenHab to Home Assistant did not take that long, maybe 7 or 8 evenings and most of the integrations, devices and automations/rules were working. I decided to configure everything file based, also did that in the past. That allows me to keep the entire config in Git, track changes easily and restore the entire system in case something breaks. Following the Home Assistant community best practices I also share my config on GitHub.

The biggest difference in configuration from my point of view is the rules aka. automatons. OpenHab has a powerful rule programming language and with the new next-gen rule engine any programming language can be used. Creating some rule here is like programming something. In Home Assistant by default one defines the automations in YAML. This is much more descriptive than programming something. At the beginning, I was little skeptical if that fulfills all my needs, but it did expect from some small exceptions where I create Python scripts to do the job. As an alternative one can plugin AppDeamon or NodeRed as well.

The Lovelace UI of Home Assistant is much more powerful than OpenHab’s sitemap approach for the Basic UI. I know OpenHab has HABPanel as well but I never got really used to it.

Integrations

Over time we collected a long list of devices from different vendors. These are the platforms, integrations, and devices we use:

Homematic
Philips Hue
Xaiomi ZigBee sensors
Apple HomeKit
Rademacher Duofern
Amazon Echo
Sonos Players
Roomba E5
Worx Landorid lawnmower robot
SonOff devices (using Tasmota)
DIY Arduino devices connected via MQTT
Uquiti Unifi network equipment
Qnap NAS
Fritzbox

Home Assistant support has integrations for 1000+ systems and devices and also OpenHab’s add-on list is at the same length. Add details list of all hubs, devices, sensors etc. I used is available on my Home Assistant config on GitHub.

Community support

I think both platforms have a great community, always will support and help. But to me, it feels that HA community is much more active and bigger. OpenHab community has a few very knowledgeable members. They are very active and supportive but at the end of the day, it very often comes back to a small group which answers the majority of questions.

Home Assistant community, in contrast, is much bigger, it is not only the active forum, they also have a Discord server to get in touch with community and core developers, many people share their configs public on GitHub (which was a huge boost for me when I started to migrate) or running very active YouTube channels. And there is a regular podcast as well.
So far I only asked a handful of questions on the community forum and always got help.

Some final thoughts

While I would consider my switch to Home Assistant as done and already have archived my OpenHab installation I know it will never be really finished. There is always some stuff to tinker and improve. I already have a to-do list of 15 items 😉

I am sure, for me, moving to Home Assistant was the right choice. And I definitely recommend to everybody who is willing to invest some time into building a local and flexible smart home solution to have a look at Home Assistant. Is Home Assistant a perfect solution? No, no smart home hub is, all have strengths and weaknesses. Also as written above OpenHab is a mature piece of software. But among these both - Home Assistant and OpenHab - Home Assistant is now the perfect fit for me.

IoT enabled Jack-O-Lantern Flamethrower

2018-11-03T00:00:00Z

Jack-O-Lantern Flamethrower

A flame-throwing jack-o’-lantern is a real Halloween highlight and definitely something to impress the trick-or-treaters and your neighbors. An internet controlled IoT flame throwing jack-o’-lantern is even better.

This Jack-O-Lantern is internet connected and can be controlled via MQTT protocol. That way the project can be integrated into a home automation solution like OpenHab or Home Assistant to control the flamethrower from there or via Alexa or Google Home.

https://www.youtube.com/watch?v=jMbAKtgw04k

You are “not so much” interested in Halloween? This is for you as well, a little fire will make even the most bold of people think twice about approaching your door.

This is actually my second version of the flame-throwing jack-o’-lantern 😀 I already build one last year using a modified room spray (like this project). But these do not allow to control the flame directly so I decided I need to build a more pro version which allows controlling the duration of the flame.

Warning: This pumpkin and playing with fire is extremely dangerous and you definitely should not make one of these. I do not endorse the manufacture or use of flamethrowers jack-o’-lanterns. The following project description is posted here are for research and entertainment purposes only.

If you are going to rebuild this project you do it at your own risks. Read the warning above - twice! Also, make sure the place the pumpkin at a safe location to not harm anybody or burn down your own house!

Hardware

The following components are needed:

A big pumpkin
Penetrating fluid like WD-40 or cheaper replacement, it’s just going to be burned anyway
A tea candle
Material for the flamethrower construction to hold the spray can
ESP8266 (Wemos D1 mini, Nodemcu) or ESP32
1-3 PIR motion sensors
Strong servo motor
SSD1306 display (optional)
Prototyping board
male & female pin headers
USB cable and power supply

The display is not really needed for this project, it is just used for fun to display some little animation and information which of the motion sensors triggered the fire.

As usual, I got the most parts from Aliexpress but all the parts should be available via other sources like ebay or amazon.com as well.

Tools

These are the tools needed:

A cutting knife
A marker
Soldering iron with solder
Tools to construct the flame-throwing mechanism

The flamethrower

Ok, again: only build this if you have read the warning and are sure what you are doing!

The key element of this project is burning penetrating fluid which if sprayed directly into a candle burns like a small flamethrower.

There are multiple ways to build the flamethrower. I used old wood pieces covered with aluminum foil to mount the spray can and candle. Maybe not the optimal solution but working, using metal parts would be a slightly better way.

Bend the thick wire like on the picture above. It should be a big lever as possible to make the most of the power of the servo motor. Hot glue or screw down the servo at the side of the construction and mount it with the wire. The lever will press down the spray nozzle when the servo is activated.

The pumpkin

The pumpkin is, of course, the most important part for a project like this 😉

First cut around the stem of the pumpkin at an angle. The top cover should be big enough, so you can later easily mount the flame thrower construction. After done cutting all the way around, remove the stem and the guts from the pumpkin. Depending on the size of the project you also need to cut out the bottom to fit in the flamethrower construction. If you have a very large pumpkin this might not be needed.

Use the marker to mark jack-o’-lanterns face. The mouth should be at the position of the spray nozzle, so that the flame can flow out well. Make sure it is big enough so that there is no setback of the flame. I the pumpkin is not big enough the flame can also be fired through a bigger nose hole. Cut the face as marked.

Place the flamethrower construction inside the pumpkin. Fix it with hot glue to stabilize it. Connect the electronics with the servo motor wires. If enough space the electronics can be placed inside the pumpkin and the PIR sensors can be inside jack-o’-lanterns eyes. Make sure you have a sufficient distance between the electronic parts and the flame.

If you have a smaller pumpkin, with not enough space inside the electronics can also be placed outside. I prefer this setup because it makes you more flexible when placing the PIR motion sensors.

The PIR motions sensors got some protection cover and habe been places to recognize the movement of approaching trick-or-treaters.

The electronics

The PIR motion sensors and the servo must be connected to the Wemos / ESP8266 board, you can use any of the Dx pins, expect D0 & D1. These two will be used by the OLED display. Connect power via USB adapter or battery pack.

The software

The software project for the ESP8288 board can be found in my GitHub repository.

After uploading the software to the board it has to be configured to connect to WiFi and MQTT. Homie provides multiple ways to do this, I prefer to create and upload a config file. Alternatively, the configuration UI can be used.

My test setup looked like this:

The code is written in C++, halloween.cpp is the main class.

The following software libraries are used. If using PlatformIO all dependencies are resolved automatically.

Homie V2 including dependencies
SSD1306 driver for ESP8266 platform
NTPClient to connect to a time server
Optionally PlatformIO environment for building the code

The IoT part

I used Homie to better modularize the software parts into dedicated “nodes” to control the servo, the display and get the PIR motion sensor inputs. Homie provides the MQTT protocol support, see Homie specification for details.

MQTT commands and config

The flamethrower supports one import command: switch on the fire 😀. It can be triggered via MQTT with homie/<device id>/fire/on/set with the value true.

Command line example:

mosquitto_pub -h <mqtt broker host> -t homie/<device id>/fire/on/set -m true

Where <devie id> is the name of the device assigned during configuration and <mqtt broker host> the hostname or ip address of your MQTT broker. This should make it easy to integrate it into home automation solution. I run OpenHab and integrated it there, just for the fun of controlling the fire via my mobile.

The following config parameters are available via config file or MQTT message (see Homie documentation how to use):

Parameter	Type	Usage
fireInterval	long	min. interval in sec between flame activations (if motion was detected) to avoid permanent fire
fireDuration	long	duration of one flame shot in ms aka. time until servo moves back to initial position
flipScreen	bool	flip the display screen vertically

The final result

This is the Jack-O-Lantern on fire.

Creepy Halloween Eyes

2018-10-30T00:00:00Z

Story

Halloween is coming in a few days and here is the first of my Halloween projects this year. I wanted to rebuild an cool Arduino project I found on YouTube - the pumpkin with moving eyes.

https://www.youtube.com/watch?v=8-jia1-PfCQ

The project is not complicated and easy to rebuild. Now we see how to do that.

Parts

The following components are used for this project:

A pumpkin
10 creepy plastic eyes
10 mini servos, for example SG90
Thin wire
Thin nails
Plastic tube (inner diameter a little bit bigger than the eyes)
Wooden or plastic stick with ~ 8mm diameter
Wemos / Lolin D1 (or equivalent NodeMCU board)
Wemos ProtoBoard (or any other protoboard will do as well)
PCB male and female pin header
AA Battery box holding 4 batteries

Tools

These are the tools needed:

A cutting knife
A small drill
A marker
Some pliers
Hot glue
Soldering iron with solder

Eyes

The trickiest part of this project are the eyes. Tricky because they should be assembled all in the same way, especially the length of the wooden stick and position of the servo should be equally to use the same servo swing parameters for all eyes.

Instructions:
Cut the tube and the wooden stick to the same length ~ 40mm. Hot glue the wooden stick to the back of the eye. Drill a hole at the end of the wooden stick. Also drill a hole into the side of the eye and one on the opposite side (see photo). Put the nail through the holes, place the eye inside the tube and hot glue both ends onto the tube edge. Move the stick at the back side of the tube should now be moving the eye.

To mount the servo hot glue it in a 90-degree angle to the wooden stick on the back side of the plastic tube. Use the wire to connect servo with the end of the wooden stick. The wire must be strong enough not to bend and move the eye.

Electronics

To move 10 servos with a small Wemos board we need some extra power. These small ESP8266 boards can only handle a current of ~500 mA in total max, enough to control two or three servo motors. To solve this, I use AA batteries as an additional power source to run all 10 servos. 2 boxes of 4 AA batteries in parallel provide 6 volts and enough juice to run the servos.

Instructions:

Solder the pin header to the Wemos D1 and solder female pin header to the prototype board to hold the D1. On the opposite side, in the middle of the prototype board solder 3 rows of male pin header with 10 pins each. These are used to connect the 10 servos. 2 rows can be connected with solder for the ground and positive lines. The pins of the third row are connected to the digital pins of the Wemos D1. I used D0 to D8 and TX pin. The ground row is connected with the ground pin of the Wemos board as well.

The battery box(es) are connected with ground row (black wire) and positive row (red wire). If more than one battery box is used to provide more power they must be connected in parallel.

Software

Compared to the hardware assembly the software is relatively simple. The small program controls an array of 10 servos and changes them randomly between an min and max position value. A short delay makes the overall eye movements more random. The full code is on GitHub.

The pumpkin

The pumpkin is, of course, the most important part of this project 😉

Instructions:
Use the marker to mark 10 circles with the size of the plastic tube used for the eyes. These should not be too close to each other to still have enough space inside.

Cut around the stem of the pumpkin at an angle. Make it big enough, this will make connecting the eyes later much easier. After done cutting, all the way around, remove the stem and the guts from the pumpkin.

Next cut the 10 circle holes for the eyes. Make sure to cut with an angle to get a little bigger hole inside.

Place the eyes in the holes and fix them from the inside with hot glue. The challenge is hot glue does not stick so well on pumpkin pulp. I turned screws into the pulp to help to fix it.

When placing the eyes make sure the servo will not be blocked.

Connect all servos to the headers on the board. Pay attention to the right connection and polarity of the connectors. Place the batteries into the boxes and put the whole electronics into a plastic bag or some box to protect it.

The final result

I placed some Bluetooth speaker next to the pumpkin playing some Halloween tunes from YouTube to have nice spooky sound effects.

433Mhz <-> MQTT gateway with some extras

2017-01-22T00:00:00Z

Smart Home 433Mhz RF <-> MQTT Gateway with Some Extras

The MQTT-433mhz-gateway-homie project is a simple bidirectional gateway to transmit and receive 433Mhz RF signals connected to MQTT. The gateway is built with a cost-effective ESP8266 WiFi chip (I used a Wemos D1 mini, NodeMCU will do as well), simple 433Mhz RF modules and an additional BMP085 sensor.

It enables you to:

receive MQTT data from a topic and send the 433Mhz signal.
receive 433Mhz signal from a traditional remote, optional map it to a channel and publish the data to a MQTT topic.
additionally, a simple temperature sensor can record the room temperature of the room where the gateway is installed.

The software is based on Homie to enable easy integration with home automation systems like OpenHab.

The final assembly looks like this:

Hardware

ESP8266 (Wemos D1 mini, Nodemcu)
RF Receiver 433Mhz
RF Transmitter 433MHz
BMP085 or BMP180 sensor breakout

I got the RF modules from https://www.sparkfun.com, others will do as well. Additional I got some Wemos Protoboards, a USB power supply with a very short cable
and an enclosure to keep all together.

The circuit inside the enclosure box:

Building the circuit

The wireing of the gateway project is very easy. The sensor, the transmitter and the receiver must be connected to VIN & GND and the GPIO pins of the ESP8266 board as shown in the table below.

Wemos D1 mini	BMP085	RF Receiver	RF Transmitter
5V	VIN	VIN	VIN
GND	GND	GND	GND
D0			DATA
D1	SCL
D2	SDA
D5		DATA

Software

The following software libraries are used. When using PlatformIO all dependencies are resolved automatically.

Homie V2 (dev) including dependencies
RCSwitch
Adafruit BMP085 Unified
Adafruit Unified Sensor
Optionally PlatformIO environment for building the code

MQTT

For detailed documentation of the MQTT topics and commands used see Homie documentation.

Sample gateway messages:

# sensor temperature reading
homie/mqtt-gateway-livingroom/temperature/degrees 23.70

Temperature value send from device.

# send RF command via MQTT & response
homie/mqtt-gateway-livingroom/MQTTto433/on/set 1394001
homie/mqtt-gateway-livingroom/MQTTto433/on 1394001

First line: MQTT command send from MQTT client or smart home solution. Translates into the code send by the RF transmitter.
Second line: Response from a device after the RF signal was transmitted.

Config

The following config parameters are available via MQTT message (see Homie documentation how to use):

Parameter	Type	Usage
temperatureInterval	long	temperature reading interval in seconds
temperatureOffset	double	temperature offset (-/+) to correct the sensor reading, for example if used in enclosure box
channels	const char*	mapping of 433MHz signals to mqtt channels, useful if used with OpenHab

All configs can be set during the init procedure of the module or via MQTT messages (see Homie specification).

Sample config:

{
    "settings": {
        "channels": "o-1:[139400];o-2:[139707];o-3:[1398097,1398100];o-4:[139803];i-1:[44618];i-2:[44620];i-3:[44623];i-4:[44638];i-5:[44700];“,
        "temperatureOffset“: -2.4,
        "temperatureInterval": 300
    }
}

Credits

This project is was inspired by 1 Technophile’s 433toMQTTto433 solution.

Homie Sensor project with BME280

2017-01-11T00:00:00Z

Homie BME280 - The Sensor

The mqtt-bme280-homie sensor project is a small and easy to integrate temperature, air pressure and humidity monitoring solution with an extra SSD1306 OLED display. Sensor data is send via MQTT and displayed on the small screen. Local time is loaded via NTP. The project is built with a cost-effective ESP8266 WiFi chip.

The software is based on Homie to enable an easy integration with home automation systems like OpenHab.

The display shows 4 screens (can be extended) in a carousel mode. temperature, humidity, air pressure and some status like IP address.

Hardware components

ESP8266 (Wemos D1 mini, Nodemcu)
BME280 sensor breakout
SSD1306 OLED display
USB power supply and cable
Enclosure

I got the BME280 breakout form Adafruit, others will do as well. The SSD1306 OLED displays I ordered at Aliexpress. This enclosure keeps everything together. Wiring is pretty simple since both sensor and display connect via I2C bus with the ESP.

Software

The following software libraries are used. If using PlatformIO all dependencies are resolved automatically.

Homie V2 (dev) including dependencies
Adafruit BME280 Driver
Adafruit Unified Sensor
SSD1306 driver for ESP8266 platform
NTPClient to connect to a time server
Optionally PlatformIO environment for building the code

Reading sensor data

The senoor data is published via MQTT according to the Homie spec. It can be read with any MQTT client:

homie/mqtt-sensor-livingroom/sensor/temperature 24.58
homie/mqtt-sensor-livingroom/sensor/humidity 32.67
homie/mqtt-sensor-livingroom/$stats/signal 94
homie/mqtt-sensor-livingroom/$stats/uptime 17126998

Config

The software can be configured via MQTT (or Homie config file), also while running. You can set sensorInterval to control the reading intervals and how often data will be published via MQTT. Additionally a temperatureOffset can be set, especially if installed within some box the BME280 sensor will give some slightly of temperate values because of the heat the ESP chip emits. Rotating the display is also possible by set the flipScreen parameter to true.