The case for calendar interface for home automations

Most home automation systems assume that your life is stable. They are built around the idea that once you’ve found the right trigger and schedule, you’re done. The robot vacuum runs everyday at 10am. The heating schedule follows a strict weekday/weekend pattern.

Set it once, forget about it.

The problem with schedules

For some automations, that’s exactly right.

My vacuum cleaner has been running on roughly the same schedule for years and I rarely think about it. But many automations don’t fit that model. Take blinds, for example. In the winter, I might want them to open later because sunrise is too early. In the summer, I might want them to stay closed during the hottest hours of the day. If I’m away for a couple days, I may want a completely different behavior.

Traditional home automation interfaces are usually built around fixed schedules. And you find yourself constantly tweaking the schedule based on your life style. Definitely not the practical interface you are looking for.

You already have a designated interface to organize your daily life: calendars

I already have a designated interface to plan and organize my day. And that’s my calendar. It contains all my meetings, events and schedules for the day, is readily available in any of my devices (from the smartphone to the laptop), is easily shareable (hello Nextcloud and CalDAV). It then simply feels like the natural interface for plugging my home automations to my daily life.

I’ll be away next weekend? That’s a bunch of full day events in my personal agenda.

I’m working from home on Wednesday. That’s also tracked in my professional agenda.

I’m having a party on Friday and don’t want to be locked outside because the blinds will shut too early? That’s another agenda item.

Compared to creating dedicated automation schedules and updating them regularly through HomeAssistant settings interface, or creating complex rules, parsing a calendar event seems the most natural interaction model. They offer:

• A familiar user experience.
• Native applications everywhere.
• Recurrence rules and exceptions.
• Easy planning weeks or months ahead.
• A clear visualization of upcoming automation changes.

Yet this is not really a first-class citizen in home automation.

My previous setup

A long time ago, I built a somewhat hacky python script around iCalendar feeds. It would read the ICS feed, process the events title and based on some internal logic trigger the automations. That was before even setting up an HomeAssistant at my place.

Eventually I migrated to Home Assistant and started using its CalDAV integration instead. It’s been a rather robust setup for the past years, mainly streamlining the inner logic to reconcile events and automation actions. It however suffered several limitations including the inability to handle concurrent events, resulting in a cohort of calendars being created to overcome it.

Unfortunately, I kept running into limitations. More recently, the integration has been broken for me for several months and the available work arounds would constrain even more the possibilities of the system. It would be next to impossible to programatically run automations at start and end of events (e.g. to switch the house to away mode and back at the beginning and end of full day events).

Back to basics: calendars triggering webhooks

After fighting with the integration for long enough, I went back to a much simpler design. Also trying to abstract as much logic from the bridging script, which was one of the issue of the initial version.

Most of my scheduled (as in time schedule, compared to the reactive one, reacting to a sensor or another event) Home Assistant automations are now exposed through webhooks.

I wrote a small script that reads calendar events and calls webhooks when events start and/or end. It is kept intentionally minimal: * The calendar event is the trigger. * The event description contains the webhook URL to call. * Event name is merely a human readable summary, but does not affect the scheduling.

The logic lies in the calendar, which acts as a ground truth. The calendar is the user interface. Home Assistant is the automation engine. The glue between them is now a small process that translates calendar events into webhook calls.

The code is very much a personal tool and 100% not production-ready. It was also a first test bed for vibe coding, which certainly does not help to turn it into anything production-ready (yet I was impressed by how well LLMs can process edge cases such as recurring events and timezones). If that might be of any use, the code lies in https://git.phyks.me/phyks/ics2webhooks.