home automation on Wouter Bulten

Home Automation / Home Assistant setup with recommended hardware: The four-year update

Thu, 06 Jul 2023 00:00:00 +0000

Four years ago, I upgraded my Home Automation setup from a Raspberry-Pi based system to a more powerful and robust system running on an Intel Nuc. Since then, many things changed in the home automation world, both on the software and hardware side. Still, even some of the early choices have paid out in the end and remained fairly stable.

In this post, I want to share an update on my current Home Assistant setup, including all the hardware I’m currently (still) using. It has been around two years since I last wrote about my setup, and a lot has changed since then - new devices have been released, I’ve experimented with different integrations, and I’ve learned a lot along the way.

Quickly jump to:

Controller
Sensors
Lights
Heating
Plugs

What did (not) change?

After several years in this home automation adventure, many things changed. However, some things in my setup also didn’t. Those patterns - the things that apparently work - are a great way to use as input to evaluate new approaches in the future. Things that “stuck” probably did something well. Some first learnings:

Home Assistant remains my go-to tool: The basis remained the same all these years: It’s still powered by Home Assistant, running locally and on the same Intel Nuc. As a platform, HA became more robust and easy to use, which also translates to more fun developing, maintaining, and using our smart home. I did switch from a customer Docker-based setup to Home Assistant OS running through Proxmox. Updating the various add-ons using Docker Compose did take manual effort, and when life is busy, I only sometimes had the time to do that. While with HA OS, such actions are a simple click of a button (automatic backup included!). The downside is that it’s a single point of failure—however, the pros of efficiently managing the whole system outweigh that.
Buy the best you can: Often also used as advice for buying cooking ingredients, spending a little more on premium devices worked out well. More expensive is not always better, but paying for features like stability, continuous software updates, and no cloud dependencies is worthwhile. For example, my Hue lights, now often updated through OTA updates in Zigbee2mqtt, are a stable core component of my setup. Or, spending a bit more on motion sensors that work well saves frustration when a sensor drops from the network. Of course, it doesn’t automatically mean that more expensive devices are automatically better, but it is something that I take into account.
Keep it simple: Home automation is firstmost a hobby. This means trying many things, including hardware and software, and eventually breaking things and starting over. I’m currently at the fifth or so generation of my setup. Still, the opposite is often true for home automation as part of life: it must be stable and run reliably. Reducing the number of vendors (e.g., for lights) and ensuring every automation fulfills a need was key to finding a good balance there.
Automate a lot, prepare for the exception: Currently, the number of buttons, dimmers, and switches in my house has dramatically reduced. Most lights work automatically based on motion sensors, light measurements, and time of day. No need to dim lights, start a scene or flip a switch. HA ensures that lights go on, dim during the evening and that our living room transitions from “working lights” to a colorful scene in the evening. Still, our mobile dashboard has a page with “kill switches” to turn off automations and disable specific automatic transitions. There is always an edge case that you cannot prepare for. A simple switch to turn off a “smart” feature can save the day.

These learnings all resulted in a new (or are the result of?) set of hardware that I’m currently using. The next few sections go more into detail on these choices.

Controllers

The “controller” is the central hub of my system. Years ago, I started with a single Raspberry Pi but, after a while, switched to a more powerful machine with a dedicated SSD. Since then, the hardware has been stable; I’m still using the same device, though the software has changed. It’s quite an investment compared to a Pi, but the flexibility and the additional power does benefit in the long run.
My first setup using the Nuc used Docker compose but since then I’ve switched to Home Assistant OS. While the Docker compose setup worked quite well, the ability to update add-ons easily from HA makes maintenance less of a hassle. By using Proxmox to run a virtual machine for Home Assistant OS I retain the flexibility to add additional services later on the same device.

Intel NUC

The main controller of the system. I use Proxmox to run a virtual machine on which I installed Home Assistant OS. By using Proxmox, I have the flexibility to add additional services later on the same machine. All the HA-related services run as add-ons in Home Assistant; this makes managing them very easy.
Using a Zigbee stick in combination with Zigbee2mqtt gives full flexibility in using smart home devices. The Nuc, therefore, also acts as my main hub for the Zigbee network.

Consisting of:

Pros: Powerfull, runs all your services on one device. Home Assistant is more responsive, especially with a large network of devices. Can also run other services.

Cons: A lot more expensive than a single Pi. Higher learning curve to set up.

For more information about the Intel NUC see any of the following links:

Hardware

Intel nuc

Software

Heating

Home automation needs inputs (sensors) and outputs (devices). The lights part of my house is fairly covered, but other exciting ways exist to actuate parts of your house. Heating is one of these and can increase comfort and optimize energy use actively.
This part of my home automation adventure is still limited, but I plan to improve it gradually over time.

Aqara Smart Radiator Thermostat E1

I wanted to control a single radiator without requiring a cloud-based setup. The Aqara radiator was a great candidate due to its compatibility with Zigbee2mqtt, availability, and relatively sleek design.
Connecting this device was not the easiest, and I encountered a few network drops. It’s a great device on paper, but more testing is required for the final verdict.

Pros: Nice design. Compatible with many radiators; a few adapters are supplied in the box.

Cons: I am still testing this device and encountered some connection problems. Based on your heating system, you might also need to be able to turn on your heating system itself (this device just controls a valve). Some features are not usable through Zigbee2mqtt (or at least not easily).

For more information about the Aqara Smart Radiator Thermostat E1 see any of the following links:

Hardware

Aqara Smart Thermostat

Software

Zigbee2mqtt

Lights

Lights are my smart home’s main ‘output’ and are controlled by various inputs. Using a Zigbee stick in combination with Zigbee2mqtt results in being not limited to a single brand. I have tested multiple brands (Hue, Ikea, OSRAM, Innr), and the lights I use the most are described here.
I started out originally with a few Hue lamps combined with cheaper Ikea bulbs. Over the years, I’ve slowly moved to using mostly Hue lights. Their light quality, ease of use, availabiltiy of fimrware updates, and connectivity are great quality-of-life upgrades. They are pricier, though, so watching out for sales is recommended.
I’m still using a few Ikea and Innr lights in places, but as most of the lights are Hue, I’ll focus on those here. If you prefer to spend a little bit less on your lights, the Ikea/Innr bulbs are a good alternative.
Why not smart switches? There is typically a debate between using smart lights and smart switches. Smart switches (e.g., Shelly devices) allow to re-use existing wall switches, are typically cheaper if you control more than one bulb, and, if wifi based, do not need a hub. However, my main selling point for smart lights is the option to change brightness, color, and light temperature per bulb. This is a feature I would not want to live without. Smart switches can dim, but you need smart lights for more features like changing colors. You can, of course, use both, but with smart enough automations, you would not need many switches.

Philips Hue Color GU10

Although a bit expensive, these bulbs’ overall (light) quality is excellent, and they have a great range of colors (compared to other lights I’ve tested). I use them to create color highlights and scenes. Connecting them is typically very easy with a Hue Dimmer Switch, and their meshing capability works well. I went with the cheaper White Ambiance variant for larger areas that do not need colors.

Pros: Very good color range. Great dimming capabilities. No problems with faulty bulbs (so far). Easy to connect. OTA (updates) through Zigbee2mqtt.

Cons: More expensive than alternatives.

For more information about the Philips Hue Color GU10 see any of the following links:

Hardware

Hue color bulb (GU10)

Software

Zigbee2mqtt

Philips Hue Color E27

Similar to the GU10 variants, but in a different form factor. Although a bit expensive, the overall (light) quality of these bulbs is excellent, and they have a great range of colors (in comparison to other lights I’ve tested). I use them to create color highlights and scenes. Connecting them is typically very easy with a Hue Dimmer Switch, and their meshing capability works well.

Pros: Very good color range. Great dimming capabilities. No problems with faulty bulbs (so far). OTA (updates) through Zigbee2mqtt.

Cons: More expensive than alternatives.

For more information about the Philips Hue Color E27 see any of the following links:

Hardware

Hue color bulb (E27)

Software

Zigbee2mqtt

Philips Hue White Ambiance E27

I use these lights as a cheaper alternative to the colored Hue lights. I use them in places where controlling brightness and color temp is sufficient. Excellent dimming quality and the color warmth has the best range in comparison to the other brands I’ve tested.

Pros: Very good temperature range. Great dimming capabilities. No problems with faulty bulbs (so far). OTA (updates) through Zigbee2mqtt.

Cons: More expensive than alternatives.

For more information about the Philips Hue White Ambiance E27 see any of the following links:

Hardware

Hue bulb

Software

Zigbee2mqtt

Philips Hue White Ambience GU10

Highest quality GU10 Zigbee lights I found so far. Excellent dimming capabilities (great for night lights) and a wide color temperature range.

Pros: Superb dimming capabilities. Nice color temperature range. OTA (updates) through Zigbee2mqtt.

Cons: More expensive than alternatives.

For more information about the Philips Hue White Ambience GU10 see any of the following links:

Hardware

Hue GU10

Software

Zigbee2mqtt

Plugs

Smart plugs are an easy way to make dumb devices a bit smarter. For example, I use one to control the charger of my wall tablet and a second one to control my (non-smart) TV.

Innr smart plug

I started out with OSRAM plugs. However, one spot in my house needed a smaller form package. The Innr smart plugs offer just that—no fancy features, just a Zigbee-based smart plug that works and doesn’t require a lot of space.

Pros: Good value for your money. Small form factor. Nice design (for a plug).

Cons: No power measurement in this configuration.

For more information about the Innr smart plug see any of the following links:

Hardware

Innr smart plug

Software

Zigbee2mqtt

OSRAM Smart+ Plug (Sylvania in the US)

Simple plug that I use for adding power on/off control to non-smart devices. I’ve only tested the EU OSRAM version, in the US this brand is available under the Sylvania name. The OSRAM hub is not required as it connects to Zigbee2mqtt.

Pros: Good value for your money. Good zigbee meshing capabilities.

Cons: No power measurement (at least in Zigbee2mqtt/Deconz). A bit bulky in comparison to others (e.g., Innr).

For more information about the OSRAM Smart+ Plug (Sylvania in the US) see any of the following links:

Hardware

Software

Zigbee2mqtt

Sensors

Sensors are what transitioned my home from an app powered home to a (aspiring) smart home. Before I had any sensors, lights were controlled by an app (e.g., the Philips Hue app), and everything was manual. Now, with the introduction of these sensors, 95% of my lights are turned on and off automatically. These sensors are also an excellent input for alarm systems.

Philips Hue Motion Sensor

The Hue motion sensor is my go-to choice for a motion sensor. It reacts fast, works well in Zigbee2mqtt, and the light sensor is fairly accurate. The temperature sensor is not great, as it can vary quite a bit between devices, but it gives some indication.

Pros: Fast response time. Realiable. Very precise light sensor. Can be installed using a magnet.

Cons: Not the cheapest sensor on the market. Larger than, for example, the Xiaomi motion sensor. Temperature sensor not very accurate.

For more information about the Philips Hue Motion Sensor see any of the following links:

Hardware

Hue motion sensor

Software

Zigbee2mqtt

Philips Hue Motion Sensor (Outdoor)

Hue motion sensor in a form factor suitable for outdoor use. One of the few Zigbee sensors available for use in the garden.

Pros: Easy to install in various configurations. Design looks nice. Feels sturdy.

Cons: Not cheap. Very sensitive, I have quite some problems with false positives. The sun affects the temperature sensor and will not be accurate for the ambient temperature.

For more information about the Philips Hue Motion Sensor (Outdoor) see any of the following links:

Hardware

Hue outdoor motion sensor

Software

Zigbee2mqtt

Series on Home Automation

This post is part of a series of posts on Home Automation. These posts usually cover a part of my own smart home or a project I worked on. I make heavy use of Home Assistant, Node-RED and AppDaemon to control my home; these posts are examples of this.

Interested in my setup?

Home Automation hardware setup

Automatically turn on tv when streaming to a Chromecast

Sun, 01 Jan 2023 00:00:00 +0000

I’m all in favor of “dumb” TVs combined with a Chromecast or Apple TV. I used to have a smart button that could toggle a smart switch to turn on my TV, which helped reduce standby mode when we weren’t using it. However, pressing the switch was an extra step that I often found inconvenient. That’s why I recently implemented a simple automation that turns on the TV automatically. Now, I can’t imagine why I didn’t set this up sooner - it’s so easy and convenient. In general, it’s a good lesson that sometimes the most simple automation can have the most practical impact.

(Hardware) requirements

HomeAssistant with NodeRED
A media player connected to the TV and configured in HA. I use a Chromecast.
A smart switch that controls power to the TV (e.g., a Innr smart plug).

Flow

The flow is effortless. When you connect to a Chromecast from a device (e.g., a smartphone), the state of the media player in HA goes from off to idle. I use that state change to turn on the TV. Usually, when the Chromecast has started the streaming service, the TV also completes its startup routine.

To turn off the TV, I do the reverse. If the state goes to off for 5 seconds, I turn off the smart switch. The five-second delay is used to disable the automation when switching from streaming services. E.g., if you switch from Netflix to Youtube on your Chromecast, it briefly goes to off. Including a 5-second delay fixes that.

Simple flow to automatically turn on the TV

Source code

You can import the flow directly in NodeRED using the following snippet:

[{"id":"12a49465495b3126","type":"server-state-changed","z":"a53c777be3d20af7","name":"TV Control state change","server":"","version":4,"exposeToHomeAssistant":false,"haConfig":[{"property":"name","value":""},{"property":"icon","value":""}],"entityidfilter":"media_player.living_room_tv","entityidfiltertype":"exact","outputinitially":true,"state_type":"str","haltifstate":"off","halt_if_type":"str","halt_if_compare":"is","outputs":2,"output_only_on_state_change":true,"for":"5","forType":"num","forUnits":"seconds","ignorePrevStateNull":false,"ignorePrevStateUnknown":false,"ignorePrevStateUnavailable":false,"ignoreCurrentStateUnknown":false,"ignoreCurrentStateUnavailable":false,"outputProperties":[{"property":"payload","propertyType":"msg","value":"","valueType":"entityState"},{"property":"data","propertyType":"msg","value":"","valueType":"eventData"},{"property":"topic","propertyType":"msg","value":"","valueType":"triggerId"}],"x":150,"y":220,"wires":[["20e6ab7719a86154"],["095a728742e847df"]]},{"id":"095a728742e847df","type":"api-call-service","z":"a53c777be3d20af7","name":"Turn on TV","server":"","version":5,"debugenabled":false,"domain":"switch","service":"turn_on","areaId":[],"deviceId":["f3bb9df57ab620c668166b9c5eabb1f2"],"entityId":[],"data":"","dataType":"jsonata","mergeContext":"","mustacheAltTags":false,"outputProperties":[],"queue":"none","x":430,"y":240,"wires":[[]]},{"id":"20e6ab7719a86154","type":"api-call-service","z":"a53c777be3d20af7","name":"Turn off TV","server":"","version":5,"debugenabled":false,"domain":"switch","service":"turn_off","areaId":[],"deviceId":["f3bb9df57ab620c668166b9c5eabb1f2"],"entityId":[],"data":"","dataType":"jsonata","mergeContext":"","mustacheAltTags":false,"outputProperties":[],"queue":"none","x":430,"y":200,"wires":[[]]}]

Series on Home Automation

Interested in my setup?

Home Automation hardware setup

Automatic dark mode for Home Assistant

Thu, 09 Jul 2020 00:00:00 +0000

In this quick tutorial, we will work on how to configure automatic dark mode for Home Assistant. It works with any theme and Lovelace interface as long as you have a dark and light version of the preferred theme. It’s easy to set up and a nice feature for wall-mounted tablets or the mobile interface. I use it primarily with my wall-mounted Fire Tablet.

With a single automation, we can setup an easy but effecive auto dark mode for Home Assistant. Left is an example interface during the day, right is the interface in the evening.

Getting a dark mode theme

To set up a dark mode, we will need two themes: one for the day/light theme, and one for the dark mode. In my setup, I make use of the “Google theme” which conveniently has both a light and dark version. You are of course free to select two different themes.

You can install the themes using HACS or by adding them to the frontend section of your configuration.yaml like so:

frontend:
  themes:
    Google Dark Theme:
      app-header-background-color: "#171717"
      app-header-text-color: "#BDC1C6"
      # .. rest of theme here
    Google Light Theme:
      app-header-background-color: "#F8F8F8"
      app-header-text-color: "#424242"
      # .. rest of theme here

Configuring users

Next, we need to make sure that we can change the theme for the users. For each user that you have configured for HA, or each user you want to enable dark mode for, go to their profile page and select “Backend selected” as their theme. “Backend selected” makes sure that we can set the theme of a user programmatically using an automation.

Make sure that all users have set their theme to backend-selected.

Creating the automation

With the theme and users setup, the only thing left is to create the automation. The automation is quite simple, based upon the state of the sun integration (which is auto-enabled), we set the correct theme. If you would prefer to start dark mode at a fixed time, you could also replace the sun trigger by a time trigger. To make sure the correct theme is always loaded, we also run the automation when HA starts up.


automation:
  # Set the correct theme during day and night
  - alias: Automatic Theme Change
    trigger:
      - platform: homeassistant
        event: start
      - platform: state
        entity_id: sun.sun
    action:
      - service_template: frontend.set_theme
        data_template:
          name: >
            {% if is_state('sun.sun', 'above_horizon') %}
              Google Light Theme
            {% else %}
              Google Dark Theme
            {% endif %}

That’s it! After adding the automation, reload Home Assistant and you should have automatic dark mode from now on. Overall, this is a very simple but rewarding automation. I mainly installed it for my wall-mounted tablet, which now blends in way more during the evening (see my post on my hardware setup for more information).

Series on Home Automation

Interested in my setup?

Home Automation hardware setup

Local face recognition for Home Assistant using TensorFlow.js, Part 2: Learning to recognize faces

Mon, 01 Jun 2020 00:00:00 +0000

This is the second post of my series on face recognition for presence detection in Home Asssistant. In this series, I am investigating how to set up a face recognition system for my smart home that works locally, without the need for cloud services or internet access, and is fully controllable. In the first post I discussed requirements, possible alternatives and the first setup of a face detection system. In this second part, we are going to look at actually learning to detect faces. I will build upon the code written in part 1, so make sure to check that out first if you haven’t done so yet.

Note: This parts follows up on Part 1 so make sure to check that out first! All code for this second part can be found in the GitHub repository under tag v0.2.1.

Hardware requirements

The hardware used in this second part is the same as in part 1. Minimally, the face recognition system should have one camera and something that can run the algorithm. In my case, I use the following:

Raspberry Pi 3B+ connected to a Raspberry Pi Camera. This is used as the main camera system. I use motionEyeOS as the OS on my Pi.
An Intel NUC8i5BEK that will run the face recognition system (and also runs Home Assistant). See my post on my hardware setup for more information.

In the examples below, I will use a static image with faces, so technically, you can follow along without a working camera. Just point the CAMERA_URL environment variable to an image on your disk.

Overview of the face detection system. In this second part of the series we are focusing on the recognition part of the pipeline.

Collecting the training set

To recognize faces, we will need a training set with faces and associated labels. To store and load those images efficiently, I am using a single directory per person. Each directory can contain multiple images of the same person. In the Github repository of the face-api.js library you can find some sample images from the cast of the Big Bang Theory.

Example image used in this post. The end goal is to recognize all faces of the Big Bang Theory cast. Retrieved from: https://github.com/justadudewhohacks/face-api.js/

Training a face matcher

To recognize faces, we are using the FaceMatcher object that can match an unknown face to a database of face descriptors. Each descriptor is a list of numbers describing features of that face. By comparing two descriptors, we can check whether the faces are the same. To train this matcher, we need to generate descriptors of all faces in our training set. In this section, we will fill out the train function that creates this matcher object:

import faceapi from "face-api.js";

async function train() {
  // Train here

  // 1. Load required models
  // 2. Find all classes (persons)
  // 3. Create descriptors for each person

  return new faceapi.FaceMatcher(faceDescriptors);
}

First, we load all the required models from disk (weights are in the GitHub repository). This makes sure that all models are ready to use.

// 1. Load required models
await faceapi.nets.ssdMobilenetv1.loadFromDisk('weights');
await faceapi.nets.faceLandmark68Net.loadFromDisk('weights');
await faceapi.nets.faceRecognitionNet.loadFromDisk('weights');

When the models are loaded, we traverse the training directory to determine which persons we need to recognize. If you use the Dockerfile associated with this project or run the code directly, example images are in ./faces, you can override this directory by setting the FACES_DIR environment variable. If you use the example faces, the snippet below should find eight persons.

// 2. Find all classes (persons)
let trainingDir = './faces'; // Default directory in the docker image
if(process.env.FACES_DIR && fs.existsSync(process.env.FACES_DIR)) {
    console.info(`Loading training images from ${process.env.FACES_DIR}`)
    trainingDir = process.env.FACES_DIR;
}

// Traverse the training dir and get all classes (1 dir = 1 class)
const classes = fs.readdirSync(trainingDir, { withFileTypes: true })
    .filter(i => i.isDirectory())
    .map(i => i.name);
console.info(`Found ${classes.length} different persons to learn.`);

For each person directory, we now discover all images. There is no validation on the images, so make sure that there are no other files in the directories (or add some basic checks).

Each image is loaded, and face descriptors are computed. In this case, we assume each person-image is a cropped version of a single face (without any background). If the images would also contain background, we would have to run a face detection algorithm first to extract the face, increasing the overall training time. The descriptors are labeled with the class name (name of the directory). Later we will work on an automated method to create these training images.

const faceDescriptors = await Promise.all(classes.map(async className => {
    
    const images = fs.readdirSync(path.join(trainingDir, className), { withFileTypes: true })
        .filter(i => i.isFile())
        .map(i => path.join(trainingDir, className, i.name));

    // Load all images for this class and retrieve face descriptors
    const descriptors = await Promise.all(images.map(async path => {
        const img = await canvas.loadImage(path);
        return await faceapi.computeFaceDescriptor(img);
    }));
    
    return new faceapi.LabeledFaceDescriptors(className, descriptors);
}));

Recognizing faces

With our face matcher trained, we can try to recognize faces in new images. To do this, we extend the motion-detected route from part 1 of this series. Make sure to read that post for more background on how I use Express and Node.JS to set up this service.

The first step is to load the new image from the camera and compute descriptors for each face in the image. In these steps, we will use the same models we loaded in the train() function.

const img = await canvas.loadImage(process.env.CAMERA_URL);

const results = await faceapi
    .detectAllFaces(img)
    .withFaceLandmarks()
    .withFaceDescriptors();

console.info(`${results.length} faces detected`);

After the faces have been detected, we can compare the descriptors using the FaceMatcher. As in part 1, I save the last detection to disk so that we can view it later.

// Create canvas to save to disk
const out = faceapi.createCanvasFromMedia(img);

results.forEach(({detection, descriptor}) => {
    // See if the descriptor matches a face in our database
    const label = faceMatcher.findBestMatch(descriptor).toString();
    console.info(`Detected face: ${label}`);

    const drawBox = new faceapi.draw.DrawBox(detection.box, { label });
    drawBox.draw(out)
});

// Write detections to public folder
fs.writeFileSync('public/last-detection.jpg', out.toBuffer('image/jpeg'));
console.log('Detection saved.');

Combining all snippets, the full route is as follows:

app.get("/motion-detected", async (req, res) => {
    res.status(200).end();
    console.info("Motion detected");

    const img = await canvas.loadImage(process.env.CAMERA_URL);

    const results = await faceapi
        .detectAllFaces(img)
        .withFaceLandmarks()
        .withFaceDescriptors();

    console.info(`${results.length} faces detected`);

    // Create canvas to save to disk
    const out = faceapi.createCanvasFromMedia(img);

    results.forEach(({detection, descriptor}) => {
        const label = faceMatcher.findBestMatch(descriptor).toString();
        console.info(`Detected face: ${label}`);

        const drawBox = new faceapi.draw.DrawBox(detection.box, { label });
        drawBox.draw(out)
    });

    // Write detections to public folder
    fs.writeFileSync('public/last-detection.jpg', out.toBuffer('image/jpeg'));
    console.log('Detection saved.');
});

For testing, it can be helpful to directly show the recognized faces on screen, instead of saving them to disk. For this, we can make a new route under /recognize that directly shows the latest detection. To do this, we have to make use of createJPEGStream() which allows us to stream canvas data to the client’s browser. The content of this route is almost equal to the existing route, with the exception in saving the image.

app.get("/recognize", async (req, res) => {

    const img = await canvas.loadImage(process.env.CAMERA_URL);

    const results = await faceapi
        .detectAllFaces(img)
        .withFaceLandmarks()
        .withFaceDescriptors();

    console.info(`${results.length} face(s) detected`);

    // Create canvas to save to disk
    const out = faceapi.createCanvasFromMedia(img);
    results.forEach(({detection, descriptor}) => {
        const label = faceMatcher.findBestMatch(descriptor).toString();
        console.info(`Detected face: ${label}`);

        const drawBox = new faceapi.draw.DrawBox(detection.box, { label });
        drawBox.draw(out)
    });

    res.set('Content-Type', 'image/jpeg');
    out.createJPEGStream().pipe(res);

});

Starting the server

With all routes defined, we can start the Express server. Note that the train function we defined earlier is async. It has to perform several actions before we can start recognizing faces, including training the face matcher. If we started up the Express server without the actions completed, the face matcher would not be able to match any faces. Instead, we first run the train function and after it completes start the server:

let faceMatcher = null;

async function start() {
    
    console.info("Start training recognition model.")
    faceMatcher = await train();
    console.info("Finished training.");

    const PORT = process.env.PORT;

    // Start express on the defined port
    app.listen(PORT, () => console.log(`Server running on port ${PORT}`))
}

start();

If you start the server and run it on the example image, the algorithm should be able to detect all faces:

Recognized faces from the BBT cast. Source: https://justadudewhohacks.github.io/face-api.js/docs/index.html

To run the algorithm on your own face, you only have to create a new directory in the faces directory and add images of your own face. After restarting the server, the algorithm will pick these images up and should be able to recognize you. The console will output how many persons can be recognized.

Adding training images on the fly

Adding training images manually is quite cumbersome. Luckily, we can also add these semi-automatically! To do this we have to use two functions from the face-api.js library: 1) detectAllFaces to detect faces in a new image; and 2) extractFaces to get the face from the image. Combined, these functions first find all faces in an image and then for each face extract a training image in the correct size.

const results = await faceapi.detectAllFaces(img);
const faces = await faceapi.extractFaces(img, results);

The faces variable will contain small images of each face in the image. I made this functionality available through a new route /add-face/:name. Apart from the two functions above, this route adds some additional checks to see if a training image can be extracted. For example, if more than one face is detected we are not sure which face to extract so we should trigger an error. The same holds if no face was detected.

// Add a new training sample
app.get("/add-face/:name", async (req, res) => {
    // Load an image
    const img = await canvas.loadImage(process.env.CAMERA_URL);
    const name = req.params.name;

    // Check if the identifier of this person is a valid directory name (letters and numbers)
    if(!name.match(/^[0-9a-zA-Z]+$/)) {
        res.status(400)
            .send("Invalid name provided for training sample.")
            .end();
        return;
    }

    console.info(`Trying to detect new training sample for '${name}'.`)
    const results = await faceapi.detectAllFaces(img);

    // This route only works when there is one person in the image
    if(results.length > 1) {
        res.status(422)
            .send("Multiple faces detected in the image, cannot save training data.")
            .end();
        return;
    }
    
    if(results.length == 0) {
        res.status(422)
            .send("No faces detected in the image, cannot save training data.")
            .end();
        return;
    }

    const faces = await faceapi.extractFaces(img, results);

    // Check if this a new person
    // trainingDir should map to your training folder
    const outputDir = path.join(trainingDir, name);
    if(!fs.existsSync(outputDir)) {
        console.info(`Creating training dir for new person '${name}'.`);
        fs.mkdirSync(outputDir);
    }

    // Write detections to training folder
    fs.writeFileSync(path.join(outputDir, `${Date.now()}.jpg`), faces[0].toBuffer('image/jpeg'));
    console.info('New training sample saved.');    
    res.status(200).send('OK');
});

By calling this route you can add a new training image for a person. To illustrate this I applied the route to the following image of Spock:

Input image to extract a training image from. Adapted from https://commons.wikimedia.org/wiki/File:Leonard_Nimoy_William_Shatner_Star_Trek_1968.JPG.

Now if you go to /add-face/spock, a new directory should be created with an extracted image of the face of Spock:

Extracted face of Spock. Adapted from https://commons.wikimedia.org/wiki/File:Leonard_Nimoy_William_Shatner_Star_Trek_1968.JPG.

After a server restart, the new training images are loaded and will be included in the FaceMatcher. To add yourself, go stand in front of your camera and call /add-face/your-name a few times in different positions. With a few training images the system should already be able to recognize you from now on!

Wrap up & next steps

Looking back at the TODO-list of part 1, the first item has now been addressed. We have also built a more efficient way of adding new training samples. The remainder of the items are more focussed on stability and further extending the usability of the system. The core functionality is present. In the future I will work on the Home Assistant integration and adding those extensions.

~~The current setup only detects faces, we still need to perform the recognition.~~
~~We need a way of easily adding new training images, for example, when a user is not recognized.~~
The server only accepts a single camera; it would be nice to support multiple cameras. Of course, you can run an instance for each camera, but maybe it’s nice to combine them.
When the face detection is running, the server cannot process other requests. A queue system could help with that.
There is no security: I wouldn’t advise running this on an unprotected network! We could add some basic authentication to protect the routes.

For now, feel free to let me know what you thought in the comments. I am happy to hear any questions or remarks! You can find the latest code in the Github repository; the code for this post is tagged v0.2.1.

Series on Home Automation

Interested in my setup?

Home Automation hardware setup

Local presence detection using face recognition and TensorFlow.js for Home Assistant, Part 1: Detection

Fri, 29 May 2020 00:00:00 +0000

Face recognition can be a nice way of adding presence detection to your smart home. A simple camera at your front door could detect who is home and trigger certain automations in Home Assistant. However, with all camera-based systems, this comes with a risk for user privacy. How are camera feeds processed? Are images stored? Is it easy to disable processing?

Most available out-of-the-box solutions use cloud-based or closed-source approaches. With something as face recognition, I want to have more control before I would consider adding it to my smart home setup. Given this, I was interested in whether I could set up such a system entirely local instead, without any reliance on external cloud services. In this series, I show how to build a face recognition system that can nicely integrate with Home Assistant for presence detection.

Given the large size of this project, this will span multiple posts. This first post lays down the groundwork with, at the end, a functioning face detection system.

Requirements for local face recognition

Before setting up this system, I made a list of requirements that should be met. There are many possible approaches/solutions, so a list of requirements can guide the design choices.

✔️ No cloud needed.: Any solution should not require an internet connection to a cloud-based service.
✔️ Local processing.: All image processing should be done locally on a machine that I control. I do not want to upload images to a server or service out of my control.
✔️ Easy to disable.: A recognition system should be easy to disable. For example, I want to automatically disable any processing when the house is in “guest mode” (i.e., guests are present).
✔️ Pre-trained models.: I don’t want to train a face detection model from scratch. To do that would require a lot of time and a well-curated training set. Of course, for the face recognition part, we will need to have a training phase. But, face detection should be doable with a pre-trained model.
✔️ Private training set.: Any images that are needed to train the face recognition system (e.g., my face), should also be stored locally. I don’t want to upload a training set to a cloud service.
✔️ Open source.: The source code should be open so that it can be inspected. This also increases the chances that the project will still work in the future.
✔️ Free / no-subscription needed.: While there is nothing against paying for software, for this experiment, I want something that can be used without a subscription. To make sure that the system will work in the future, I especially don’t want to be dependent on an external service. There are many face recognition systems available that are free to use, but companies can decide to end support or introduce new pricing models.

Luckily, meeting all requirements is possible! But, it does require some programming to set everything up.

Choosing a recognition system

During my search for face recognition systems, I found several systems that could be used. Some of these are cloud-based, others are local. A non-complete overview can be found below. I wasn’t able to test all methods myself, so I used information from the docs. Found a error in the overview above? Let me know! The requirements score is based on how many of the requirements the solution meets.

Solution	Examples	Internet needed?	Pricing / subscription	Training data	Processing (inference)	Requirements score
Cloud solution	Google Cloud Microsoft Face	Yes	Pay-per-use with free starter plans	None¹	Test images are uploaded	2/7
External service, local processing	Deepstack Facebox	No³	Free with limits / unclear	None¹	Test images are processed locally, but often closed-source	5/7
Local, self-trained	Any deep learning framework	No	Free³	Database with faces	Local, full control	6/7
Pre-trained, local processing	face_recognition face-api.js	No	Free³	None¹	Local, full control	7/7

1] Some training data is needed to recognize faces (instead of plain detection).
2] Some of these systems have keys which mean they have to phone-home at some point.
3] Free as in "no money." You still have to pay with your own development time of course.

Based on this overview, I chose to go for one of the libraries that has support for pre-trained models and supports local processing: face_recognition and face-api.js. face_recognition is written in Python and uses the dlib library as a backend. face-api.js runs on Javascript/Node using TensorFlow.js as the backend. Both projects have support for face detection and recognition, with pre-trained models.

In the end, after a lot of testing, I chose face-api.js. I always wanted to experiment more with TensorFlow.js, and, given that I use python during my day-job, JS would be a nice change of scenery. If you are more interested in a pure-python setup, make sure to check out face_recognition. Note, that even though we will set everything up in JS, the actual processing is done in C++ using the Tensorflow bindings.

Hardware requirements

At the minimum the face recognition system should have one camera and something that can run the algorithm. In my case I use the following:

Raspberry Pi 3B+ connected to a Raspberry Pi Camera. This is used as the main camera system. I use motionEyeOS as the OS on my Pi.
An Intel NUC8i5BEK that will run the face recognition system (and also runs Home Assistant).

Of course, any other combination can be used. Just make sure that the camera has an URL where you can retrieve an image snapshot. Ideally, the camera also has built-in motion detection so that you can trigger face recognition at the right time. The compute unit that runs the algorithm should be strong enough, or you can expect a delay in processing. I haven’t tried this on a Raspberry Pi, let me know how it performs if you try it out!

For this project I use a Raspbbery Pi in combination with a Pi Camera. Image from https://projects.raspberrypi.org/en/projects/getting-started-with-picamera

Part 1: Building a face detection system

In this first part of the series, we set everything up for simple face detection. The overview of the application is shown in the figure below. A camera, in my case a Raspberry Pi Camera, sends a request to the application when it detects motion. This is done using a simple HTTP GET request. You could also trigger this from Home Assistant using an automation triggered by a motion sensor, for example.

Upon receiving the webhook, the application retrieves a snapshot from the camera, e.g., the last recorded frame. This frame is processed using the detection algorithm. If a face is detected, we can send a request to Home Assistant that something was detected. Additionally, we save the snapshot with a bounding box around the face. This image can be viewed by us (the user), for example, through the Home Assistant dashboard.

Overview of the face detection system.

The full source code for part 1 can be found on the ha-facerec-js GitHub repository (v0.1.0).

Setting up the webhook

To listen for a request from the camera (the webhook), we set up a simple express webserver. The server listens for requests on the /motion-detected endpoint.

import express from 'express';

// Initialize express
const app = express();
const PORT = process.env.PORT;

// Start express on the defined port
// Start express on the defined port
app.listen(PORT, () => console.log(`Server running on port ${PORT}`))

app.get("/motion-detected", async (req, res) => {
  // Send a OK back to the camera
  res.status(200).end();

  // Do something here

});

To trigger this route, go to your MotionEyeOS admin panel and enable motion detection. Add the URL of your running express instance under “webhook URL.” Most probably, this is :.

Setup the webhook in your camera’s control panel.

Running face detection

After motion has been detected, we can start looking for faces. To do this, we request the last frame of the camera. Using node-canvas we can make use of the Canvas functionality within Node.js (normally only possible within a browser). Loading the image becomes as easy as calling the URL of the camera (here defined using the CAMERA_URL env variable):

import canvas from 'canvas';

// From inside an async function:
const img = await canvas.loadImage(process.env.CAMERA_URL);

With the image loaded, we can pass this to the face-api.js library to actually detect faces. For this, I make use of the SSD MobileNetV1 network included with the library. This network has good performance in detecting faces but is a bit slower than other alternatives. Luckily we can speed this up later; see the next section for more info.

The network weights are loaded from disk, and all processing is done locally on the device. The weights of these networks are stored in the Github repository for you to download.

// Load network from disk
await faceapi.nets.ssdMobilenetv1.loadFromDisk('weights');

// Detect faces
const detections = await faceapi.detectAllFaces(img, new faceapi.SsdMobilenetv1Options({ minConfidence: 0.5 }));

// Create a new image with a bounding box around each face
const out = faceapi.createCanvasFromMedia(img);
faceapi.draw.drawDetections(out, detections);

With faces detected, we can perform our actions. For this example, I save the snapshot with the detected faces to disk:

fs.writeFileSync('public/last-detection.jpg', out.toBuffer('image/jpeg'));

The exported image can later be retrieved using a new route in Express. You could, for example, show the last detected face in your Home Assistant dashboard using a camera setup.

// Load network from disk
await faceapi.nets.ssdMobilenetv1.loadFromDisk('weights');

// Detect faces
const detections = await faceapi.detectAllFaces(img, new faceapi.SsdMobilenetv1Options({ minConfidence: 0.5 }));

// Create a new image with a bounding box around each face
const out = faceapi.createCanvasFromMedia(img);
faceapi.draw.drawDetections(out, detections);

With faces detected, we can perform our actions. For this example, I save the snapshot with the detected faces to disk:

fs.writeFileSync('public/last-detection.jpg', out.toBuffer('image/jpeg'));

The exported image can later be retrieved using a new route in Express. You could, for example, show the last detected face in your Home Assistant dashboard using a camera setup.

Speeding up recognition

The MobileNetV1 network is quite slow when we run it in Javascript. Luckily, there is a special package that offers Node bindings for the Tensorflow C++ backend. Using this package drastically speeds up the detection. Using these bindings is as simple as loading them in the script:

// Load TF bindings to speed up processing
if (process.env.TF_BINDINGS == 1) {
    console.info("Loading tfjs-node bindings.")
    import('@tensorflow/tfjs-node');
} else {
    console.info("tfjs-node bindings not loaded, speed will be reduced.");
}

Note: The bindings don’t always work out of the box in my experience. If you encounter errors, first try to run everything without the bindings loaded.

Tying everything together

Combining all snippets from above results in a simple web server that can detect faces on command. I run this server inside a docker container as part of my home automation docker setup. You can find the Dockerfile on the GitHub repository. The full source code of the script is as follows:

import express from 'express';
import faceapi from "face-api.js";
import canvas from 'canvas';
import * as path from 'path';
import fs from 'fs';

// Load TF bindings to speed up processing
if (process.env.TF_BINDINGS == 1) {
    console.info("Loading tfjs-node bindings.")
    import('@tensorflow/tfjs-node');
} else {
    console.info("tfjs-node bindings not loaded, speed will be reduced.");
}

// Inject node-canvas to the faceapi lib
const { Canvas, Image, ImageData } = canvas;
faceapi.env.monkeyPatch({ Canvas, Image, ImageData });

// Initialize express
const app = express();
const PORT = process.env.PORT;

// Start express on the defined port
app.listen(PORT, () => console.log(`Server running on port ${PORT}`))

// Webhook
app.get("/motion-detected", async (req, res) => {
  res.status(200).end();

  // Load network
  await faceapi.nets.ssdMobilenetv1.loadFromDisk('weights');

  // Request image from the camera
  const img = await canvas.loadImage(process.env.CAMERA_URL);

  // Detect faces
  const detections = await faceapi.detectAllFaces(img, new faceapi.SsdMobilenetv1Options({ minConfidence: 0.5 }));
  const out = faceapi.createCanvasFromMedia(img);
  faceapi.draw.drawDetections(out, detections);

  // Write detections to public folder
  fs.writeFileSync('public/last-detection.jpg', out.toBuffer('image/jpeg'));
  console.log('Detection saved.');
});

// Static route, give access to everything in the public folder
app.use(express.static('public'));

By running the server, setting CAMERA_URL to the snapshot of the camera, we can now detect faces. As an example, I ran the code on an image of crowd from Wikipedia. The result is shown below. The algorithm is quite capable of detecting almost all faces in even a single frame.

Face detection algorithm applied on image of Wikipedia (CC BY-SA).

Of course, were are not there yet. Detection is nice, but for presence, we also need to recognize faces. There are also some other things left to improve. For example:

The current setup only detects faces, we still need to perform the recognition.
The server only accepts a single camera, it would be nice to support multiple cameras. Of course, you can run an instance for each camera, but maybe it’s nice to combine them.
When the face detection is running, the server cannot process other requests. A queue system could help with that.
There is no security: I wouldn’t advise to run this on an unprotected network! We could add some basic authentication to protect the routes.

All of this will be covered in the next posts. To continue you can read part 2. For now, feel free to let me know what you thought in the comments. You can find the latest code in the Github repository, the code for this post is tagged v0.1.0.

Continue to part 2 →

Series on Home Automation

Interested in my setup?

Home Automation hardware setup

Setting up Home Automation with Docker Compose: Home Assistant, Node-RED, and more

Thu, 17 Oct 2019 00:00:00 +0000

Recently, I migrated my whole home automation setup from a group of Raspberry Pis to an Intel NUC; specifically the Intel NUC8i5BEK. Due to an increasingly larger set of devices, a single Pi for running Home Assistant and Node-RED did not cut it anymore. See my post on my hardware setup for more information.

With the introduction of the Intel Nuc to my setup, the way I configured my system also changed. Previously, I used Hass.io for managing all services. With the new NUC, I wanted to be more in control. I ended up adopting Docker and Docker Compose for my setup.

During the migration of my setup, it took quite some time to figure out the configurations for all services. In this blog post, I share the configurations I eventually came up with, and which now power my system. I now have running containers for Home Assistant, Node-RED, AppDaemon, MariaDB, VS Code, and Deconz.

Any questions about these setups? Feel free to add a question in the comments. Tips to improve it, those are very welcome too!

Table of contents

Use of the .env file
Note on volumes
Docker compose for Home Assistant
Docker compose for MariaDB
Docker compose for Conbee / Deconz
Docker compose for Node-RED
Docker compose for AppDaemon
Docker compose for VS Code
docker-compose.yaml overview

Updates

14-05-2020: Updated VS Code setup.

Use of the .env file

Al my configurations are pushed to Github as a way of back up. It’s not really desirable to commit secrets (passwords, tokens, etc.), so you don’t want these in your config file. Luckily, docker-compose can read these from an .env file. In all the examples below, I assume that you have a .env file with the required variables.

Note on volumes

Most of the docker containers use volumes to store persistent data. Without these volumes, all data and configuration would be lost if you restart one of the containers. Make sure to check the volumes config of each configuration block and update accordingly to your liking.

I store all my configuration (e.g., al volumes) in a central directory like ~/homeautomation-config. This directory can then be easily backed up on a remote device.

Docker compose for Home Assistant

The Home Assistant docker is the main container of my smart home setup. Most configuration is done within HA itself, so it’s a matter of spinning up the container. I use MariaDB for storing all event data, so that container needs to start first. I also make sure that my Zigbee hub is running before starting HA.

Website:

Home Assistant

ENV variables:

LOCAL_USER: (Optional) Map the docker user to your user id. This ensures that files can be edited without root access. Especially useful in combination with the VSCode server image.

# HomeAssistant
homeassistant:
  container_name: home-assistant
  image: homeassistant/home-assistant
  volumes:
    # Local path where your home assistant config will be stored
    - :/config
    - /etc/localtime:/etc/localtime:ro
  restart: unless-stopped
  network_mode: host
  depends_on:
    # MariaDB is optional (only if you would like to use a different database for HA).
    - mariadb
    # Deconz is optional (only if you use the deconz Zigbee hub).
    - deconz
  user: "${LOCAL_USER}:${LOCAL_USER}"

Docker compose for Database using MariaDB

I use MariaDB as my main database for Home Assistant. HA gets its own user account to access the db.

Website:

MariaDB

ENV variables:

MYSQL_ROOT_PASSWORD: Root password for the service.
HA_MYSQL_PASSWORD: Password that home assistant will use to connect with the db.
LOCAL_USER: (Optional) Map the docker user to your user id. This ensures that files can be edited without root access.

# MariaDb
mariadb:
  image: mariadb/server:10.3
  container_name: mariadb
  restart: unless-stopped
  environment:
    MYSQL_ROOT_PASSWORD: "${MYSQL_ROOT_PASSWORD}"
    MYSQL_DATABASE: ha_db
    MYSQL_USER: homeassistant
    MYSQL_PASSWORD: "${HA_MYSQL_PASSWORD}"
  user: "${LOCAL_USER}:${LOCAL_USER}"
  volumes:
    # Local path where the database will be stored.
    - :/var/lib/mysql
  ports:
    - "3306:3306"

Docker compose for Zigbee hub using Deconz

To control my devices, I use the ConBee USB ZigBee hub from Dresden Elektroniks. It’s a great device with a vast list of compatible devices. Luckily, there is a Docker image that can be used to run their software. It even has support for viewing the mesh network through VNC.

Hardware:

Conbee 2 (I'm using the Conbee 1, but the v2 is slightly improved and should be bought from now on.)

Website:

Conbee 1 or Conbee 2

ENV variables:

VNC_PASSWORD: Password to use when connecting to the VNC server (for viewing the mesh network).

Additional notes:

You need to map the right USB device to the container. For the Conbee 2 the device mapping is slightly different. You can use `/dev/ttyACM0` instead of `dev/ttyUSB0`.

# Deconz
deconz:
  container_name: deconz
  image: marthoc/deconz
  restart: unless-stopped
  network_mode: host
  environment:
    # You can access Deconz at this port
    DECONZ_WEB_PORT: 8080
    DECONZ_WS_PORT: 8088

    # Set VNC_MODE to 0 to disable it completely
    DECONZ_VNC_MODE: 1
    DECONZ_VNC_PORT: 5900
    DECONZ_VNC_PASSWORD: "${VNC_PASSWORD}"
  volumes:
    - /etc/localtime:/etc/localtime:ro
    - /etc/timezone:/etc/timezone:ro
    # Replace  with a path where all deconz config will be stored.
    - :/root/.local/share/dresden-elektronik/deCONZ
  devices:
    - "/dev/ttyUSB0:/dev/ttyUSB0"

Docker compose for Node-RED

Node-RED powers most of the automations in my smart home. After setting up the container, you can install extensions and configure the connection between Home Assistant and Node-RED.

Website:

Node-RED

ENV variables:

LOCAL_USER: (Optional) Map the docker user to your user id. This ensures that files can be edited without root access. Especially useful in combination with the VSCode server image.

Additional notes:

When the Node-RED container is running, you can install the Home Assistant extension and connect Node-RED with HA. You only have to do this once. After the initial install, all configurations and extension are saved.
The Home Assistant extension for Node-RED is node-red-contrib-home-assistant-websocket. You can install this extension within Node-RED by going to "Manage palette" in the menu.

  # Node-RED
  nodered:
    container_name: nodered
    image: nodered/node-red
    ports:
      - "1880:1880"
    volumes:
      # Local path where all Node-RED config will be stored.
      - :/data
    depends_on:
      - homeassistant
    environment:
      TZ: "Europe/Amsterdam"
    user: "${LOCAL_USER}:${LOCAL_USER}"
    restart: unless-stopped

Docker compose for AppDaemon

AppDaemon is a great way to create small Python-based scripts that can interface with Home Assistant. AppDaemon runs in its own container and needs a “long lived access token” from HA to communicate.

Website:

AppDaemon

ENV variables:

SERVER_IP: URL of Home Assistant.
HA_APPDAEMON_KEY: Long lived access token generated in Home Assistant.
LOCAL_USER: (Optional) Map the docker user to your user id. This ensures that files can be edited without root access. Especially useful in combination with the VSCode server image.

appdaemon:
  container_name: appdaemon
  restart: unless-stopped
  image: acockburn/appdaemon:latest
  environment:
    HA_URL: "http://${SERVER_IP}:8123"
    TOKEN: "${HA_APPDAEMON_KEY}"
    DASH_URL: "http://${SERVER_IP}:5050"
  ports:
    - "5050:5050"
  volumes:
    # Set which local directory will contain all your app daemon configuration
    - :/conf
  depends_on:
    - homeassistant
  user: "${LOCAL_USER}:${LOCAL_USER}"

Docker compose for VS Code Server

Not technically required for Home Assistant, but Visual Studio Code Server is a great way to add a remote IDE to your setup. When the container is running, you have access to a complete IDE within your browser.

Website:

cdr/code-server

ENV variables:

VSCODE_PASSWORD: Password you want to use with VS Code

# Visual Studio code
vscode:
  container_name: vscode
  image: codercom/code-server
  volumes:
    # Set  to the directory you want to open in VS Code.
    - :/home/coder/project
    #  should point to a local dir where vs code stores its data.
    - :/home/coder/.local/share/code-server
  ports:
    - "8443:8080"
  command: code-server --auth password --disable-telemetry /home/coder/project
  environment:
    PASSWORD: "${VSCODE_PASSWORD}"
  restart: unless-stopped

Complete docker compose file

For reference, the .env and docker-compose.yaml file:

.env

SERVER_IP= 0.0.0.0
HA_APPDAEMON_KEY=some long accces token
VSCODE_PASSWORD=password
LOCAL_USER=1000
VNC_PASSWORD=password
MYSQL_ROOT_PASSWORD=password
HA_MYSQL_PASSWORD=password

docker-compose.yaml

version: '3'
services:
  # HomeAssistant
  homeassistant:
    container_name: home-assistant
    image: homeassistant/home-assistant
    volumes:
      # Local path where your home assistant config will be stored
      - :/config
      - /etc/localtime:/etc/localtime:ro
    restart: unless-stopped
    network_mode: host
    depends_on:
      # MariaDB is optional (only if you would like to use a different database for HA).
      - mariadb
      # Deconz is optional (only if you use the deconz Zigbee hub).
      - deconz
    user: "${LOCAL_USER}:${LOCAL_USER}"

  # MariaDb
  mariadb:
    image: mariadb/server:10.3
    container_name: mariadb
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: "${MYSQL_ROOT_PASSWORD}"
      MYSQL_DATABASE: ha_db
      MYSQL_USER: homeassistant
      MYSQL_PASSWORD: "${HA_MYSQL_PASSWORD}"
    user: "${LOCAL_USER}:${LOCAL_USER}"
    volumes:
      # Local path where the database will be stored.
      - :/var/lib/mysql
    ports:
      - "3306:3306"

  # Deconz
  deconz:
    container_name: deconz
    image: marthoc/deconz
    restart: unless-stopped
    network_mode: host
    environment:
      # You can access Deconz at this port
      DECONZ_WEB_PORT: 8080
      DECONZ_WS_PORT: 8088

      # Set VNC_MODE to 0 to disable it completely
      DECONZ_VNC_MODE: 1
      DECONZ_VNC_PORT: 5900
      DECONZ_VNC_PASSWORD: "${VNC_PASSWORD}"
    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /etc/timezone:/etc/timezone:ro
      # Replace  with a path where all deconz config will be stored.
      - :/root/.local/share/dresden-elektronik/deCONZ
    devices:
      - "/dev/ttyUSB0:/dev/ttyUSB0"

  # Node-RED
  nodered:
    container_name: nodered
    image: nodered/node-red
    ports:
      - "1880:1880"
    volumes:
      # Local path where all Node-RED config will be stored.
      - :/data
    depends_on:
      - homeassistant
    environment:
      TZ: "Europe/Amsterdam"
    user: "${LOCAL_USER}:${LOCAL_USER}"
    restart: unless-stopped

  # AppDaemon
  appdaemon:
    container_name: appdaemon
    restart: unless-stopped
    image: acockburn/appdaemon:latest
    environment:
      HA_URL: "http://${SERVER_IP}:8123"
      TOKEN: "${HA_APPDAEMON_KEY}"
      DASH_URL: "http://${SERVER_IP}:5050"
    ports:
      - "5050:5050"
    volumes:
      # Set which local directory will contain all your app daemon configuration
      - :/conf
    depends_on:
      - homeassistant
    user: "${LOCAL_USER}:${LOCAL_USER}"

  # Visual Studio code
  vscode:
    container_name: vscode
    image: codercom/code-server:v2
    volumes:
      # Set  to the directory you want to open in VS Code.
      - :/home/coder/project
      #  should point to a local dir where vs code stores its data.
      - :/home/coder/.local/share/code-server
    ports:
      - "8443:8443"
    command: code-server --auth password --port 8443 --disable-telemetry /home/coder/project
    environment:
      PASSWORD: "${VSCODE_PASSWORD}"
    restart: unless-stopped

Series on Home Automation

Interested in my setup?

Home Automation hardware setup

My Home Assistant Smart Home setup with hardware list

Mon, 04 Feb 2019 00:00:00 +0000

On this page I keep track of my current Smart Home setup, built around Home Assistant, Deconz and Node-RED. So, if you are interested in my setup please read on. The list of devices I use has grown organically over time, sometimes based on a certain need (like a proper light sensor), and sometimes based on a specific sale or interest for a device. Still, if I had to start over I would still pick many of these devices for a second time.

Note: The pros and cons described here are my personal experiences. 🙂

Note 2: All trademarks, logos and brand names are the property of their respective owners. All company, product and service names used in this website are for identification purposes only. Otherwise, it would be very hard to explain which hardware devices or software I use or consider for my home automation project! 😉

Quickly jump to:

Controller
Sensors
Lights
Buttons and switches
Dashboards
Plugs

Controllers

My smart home runs on Home Assistant, App Deamon, Node-RED, and Deconz. I started small with a set of Raspberry Pis. At some point, I required a bit more processing power and switched to an Intel NUC with Docker.

Intel NUC

Main controller of the system running all services through Docker.

Consisting of:

Pros: Powerfull, runs all your services on one device. Home Assistant is more responsive, especially with a large network of devices. Can also run other services. Docker (with Docker compose) gives more flexibility.

Cons: A lot more expensive than a single Pi. Higher learning curve.

For more information about the Intel NUC see any of the following links:

Hardware

Intel nuc

Software

ConBee

My main Zigbee hub using software from Dresden Electronics, connected to my Intel Nuc. I use the v1 version, but a newer v2 version is now available. The ConBee is compatible with most of devices of Hue, Osram, Innr, Ikea and Xiaomi. I chose for the USB version so that I could always switch to another device if needed. As I started with a Raspberry pi, and then moved to an Intel Nuc this turned out to be a good choice.

Pros: Huge list of compatible devices, see the compatbility list. Nice interface for joining lights, sensors and switches. The GUI can be used to debug/view the Zigbee network (gives great insight in the mesh abilities).

Cons: More expensive than the flash-your-own Zigbee radios. Higher learning curve than the vendor hubs.

For more information about the ConBee see any of the following links:

Hardware

Conbee

Software

Raspberry Pi 3B+

My first smart home setup consisted of Home Assistant, App Daemon and Node-RED are all running on a Raspberry Pi. Two other Pis, one for Deconz and one for PiHole, completed the set. While I could have ran all these services on a single device (like a NUC), I wanted to start small with a single Pi, and I have extended it since then. Currently, the Raspberry Pis have been replaced by a single Intel NUC.

Pros: Cheaper / easier to start with.

Cons: Less room for future upgrades, SD cards will not run indefinately.

For more information about the Raspberry Pi 3B+ see any of the following links:

Hardware

Raspberry Pi 3B+

Software

Dashboards

A tablet-powerd dashboard is a great way of interacting with your house. I use it as the main control panel that gives access to the most important features and settings. It’s also a very convenient way of giving guests access to your smart home system without having them to install an app or browsing to a website.

Amazon Fire Tablet

I use a basic Fire 7 tablet from Amazon for my dashboard. In combination with the Fully Kiosk Browser it’s a really conventient way of controling my smart home. Fire OS (what runs on these tablets) can be a bit limiting but, for me, is enough for running a dashboard.

Pros: Good price

Cons: Not the fastests tablets. Not available in all countries. FireOS can be restrictive.

For more information about the Amazon Fire Tablet see any of the following links:

Hardware

Fire tablet

Software

Fully Kiosk Browser

Buttons and switches

Philips Hue Smart Dimmer Switch

A four-button wireles switch that is often present in the starter packs of Philips Hue. Its intended use is to dim lights, however I use it as a remote for my Sonos-powered music system. Using Deconz and Node-RED I mapped the single buttons to music functions: shuffle, volume and skipping songs.

Pros: Four buttons, wall mount using magnets.

Cons: Labels on the buttons (can be a pro or con). Bit more expensive than a single Xiaomi button.

For more information about the Philips Hue Smart Dimmer Switch see any of the following links:

Hardware

Hue Dimmer Switch

Xiaomi Aqara wireless switch (WXKG11LM)

Very useful and cheap (around €7) switch with a single button. I have spread several of these around my house controlling a wide range of functions. They are especially usefull to add a simple light switch to rooms.

The Xiaomi hub is not required as it connects to my ConBee. An alternative is to run Zigbee2mqtt.

Pros: Small form factor. Good price.

Cons: Not available locally

For more information about the Xiaomi Aqara wireless switch (WXKG11LM) see any of the following links:

Hardware

Can be bought on various websites. Usually cheapest on Gearbest or AliExpress.

Software

Xiaomi Aqara wireless switch (WXKG01LM)

Comparable to the other switch (see above), but this one has a bit larger touch area. I use one in my kitchen as I can activate this switch with my elbows which is usefull during cooking. Its a bit more espensive though, usually around €9. The Xiaomi hub is not required as it connects to my ConBee. An alternative is to run Zigbee2mqtt.

Pros: Larger touch area.

Cons: Not available locally. Bit more expensive than WXKG11LM.

For more information about the Xiaomi Aqara wireless switch (WXKG01LM) see any of the following links:

Hardware

Can be bought on various websites. Usually cheapest on Gearbest or AliExpress.

Software

Lights

Lights are the main ‘output’ of my smart home and are controlled by various inputs. As I use Deconz as my main Zigbee hub I’m not limited to a single brand. I have tested multiple brands (Hue, Ikea, OSRAM, Innr) and the lights I use the most are described here.

Philips Hue Color Bulbs

Although a bit expensive, the quality of these bulbs is very good and they have a great range of colors (in comparison to other lights I’ve tested). I use them to create some color highlights. For larger areas that do not need colors I went with the cheaper White Ambiance variant.

Pros: Very good color range. Great dimming capabilities. No problems with faulty bulbs (so far).

Cons: More expensive than alternatives.

For more information about the Philips Hue Color Bulbs see any of the following links:

Hardware

Hue color bulb

Software

Philips Hue White Ambiance Bulbs

I use these lights as a cheaper alternative to the color Hue lights. I use them in places where controlling brightness and color temp is sufficient. Excellent dimming quality and the color warmth has the best range in comparison to the other brands.

Pros: Very good temperature range. Great dimming capabilities. No problems with faulty bulbs (so far).

Cons: More expensive than alternatives.

For more information about the Philips Hue White Ambiance Bulbs see any of the following links:

Hardware

Hue bulb

Software

Ikea Tradfri GU10 dimmable led

What can you do wrong with a €7 smart light? Not much. These lights are very good as a basic lights for rooms that do not need more than dimming. I did have some problems with some of these though, like flickering when they were off or not wanting to connect to my hub.

The Ikea hub is not required as it connects to my ConBee. An alternative is to run Zigbee2mqtt.

Pros: Great entry-level light. One of the cheapest Zigbee lights available. Decent light quality. Good value for your money.

Cons: Dimming capabilities are moderate, 1% brightness of this light is 10% of a comparable Hue light. Had some problems with faulty bulbs.

For more information about the Ikea Tradfri GU10 dimmable led see any of the following links:

Hardware

Can be bought at any Ikea store.

Software

Philips Hue White Ambience GU10

Highest quality GU10 Zigbee lights I found so far. Excellent dimming capabilities (great for night lights) and a wide color range. If they would have been cheaper I would have bought more of these.

Pros: Superb dimming capabilities. Nice color temperature range.

Cons: More expensive than alternatives.

For more information about the Philips Hue White Ambience GU10 see any of the following links:

Hardware

Hue GU10

Software

Ikea Tradfri GU10 dimmable led + color temp

Double the price of the simple Tradfri light but includes adds color temperature. The range of temperatures and the dimming capabilties are still not great, but the lights have a very good value for the price. If you’re not to picky for light quality, these lights are a great starter-buy.

The Ikea hub is not required as it connects to my ConBee. An alternative is to run Zigbee2mqtt.

Pros: Very good price. Decent light quality. Has color temperature support.

Cons: Dimming capabilities are moderate, 1% brightness of this light is 10% of a comparable Hue light. Setting temperature and brightness at the same time can be difficult (more info).

For more information about the Ikea Tradfri GU10 dimmable led + color temp see any of the following links:

Hardware

Can be bought at any Ikea store.

Software

Plugs

Smart plugs are an easy way to make dumb devices a bit smarter. For example, I use one to control the charger of my wall tablet and a second one to control my (non-smart) TV.

OSRAM Smart+ Plug (Sylvania in the US)

Simple plug that I use for adding on/off control to non-smart devices. I’ve only tested the EU OSRAM version, in the US this brand is available under the Sylvania name.

The OSRAM hub is not required as it connects to my ConBee. An alternative is to run Zigbee2mqtt.

Pros: Good value for your money. Good zigbee meshing capabilities.

Cons: No power measurement (at least in Deconz).

For more information about the OSRAM Smart+ Plug (Sylvania in the US) see any of the following links:

Hardware

Software

Fully Kiosk Browser

Sensors

Sensors are what transitioned my home from an app powered home to a smart home. Before I had any sensors, lights were controlled by an app (e.g. the Philips Hue app) and everything was manual. Now, with the introduction of these sensors, most lights can be turned on and off automatically.

Xiaomi Aqara motion sensor (RTCGQ11LM)

In my opinion, the best motion sensor for this price. I use this sensor in all places where I want to automate something based on motion. Usually sells for around €10 (keep an eye on sales!). The device also includes a light sensor but the sensor readings are very inaccurate. The motion detection range is quite good but large rooms will need more than one.

The Xiaomi hub is not required as it connects to my ConBee. An alternative is to run Zigbee2mqtt.

Pros: Best for the price. Small form factor.

Cons: Not available locally. Sends max. 1 update per minute.

For more information about the Xiaomi Aqara motion sensor (RTCGQ11LM) see any of the following links:

Hardware

Can be bought on various websites. Usually cheapest on Gearbest or AliExpress.

Software

Xiaomi Aqara door sensor (MCCGQ11LM)

Door sensors are one of the most usefull sensors to integrate in to a smart home. They can of course be used as part of an alarm on both windows and doors. Moreover, my main use for them is to turn on lights when a door is opened. This makes sure that lights are on even if the motion sensors did not register the motion yet and results in a nice transition.

These sensors from Aqara are one of the cheapest available, but work great. They are really small and sell for around €7.

The Xiaomi hub is not required as it connects to my ConBee. An alternative is to run Zigbee2mqtt.

Pros: Best for the price. Very small.

Cons: Not available locally

For more information about the Xiaomi Aqara door sensor (MCCGQ11LM) see any of the following links:

Hardware

Can be bought on various websites. Usually cheapest on Gearbest or AliExpress.

Software

Philips Hue Motion Sensor

The Hue motion sensor is bit more expensive than the Aqara motion sensors and is also larger in size. I still bought one as the light sensors in the Aqara sensors are not very precise and I wanted to monitor natural light intensity.

Pros: Very precise light sensor. Can be installed using a magnet.

Cons: Expensive. Larger than the Xiaomi version.

For more information about the Philips Hue Motion Sensor see any of the following links:

Hardware

Hue motion sensor

Software

Series on Home Automation

Interested in my setup?

Home Automation hardware setup

Node-RED based custom full-room wake-up light

Sun, 27 Jan 2019 00:00:00 +0000

In a previous post I showed a wake-up light using Home Assistant and the default YAML configuration. In this post I’ll show my current setup which makes use of Node-RED.

As with my previous system, this wake-up light’s function is to light up my complete bedroom just before I need to wake up. The system works with any smart lamp that is compatible with HA, this includes Philips Hue and IKEA Tradfri lamps. I use it with a few GU10 bulbs (like the Hue GU10 lights). If you want you could even use some color-enabled bulbs to include a nice color transition mimicking a sun rise.

In this post I’ll show you how to build this system. The automation will be configurable (on/off, time) and has a switch to disable it on weekends.

The complete flow.

Dashboard widget of the Wake-up light component. All functions are configurable through the Home Assistant dashboard.

Example hardware

I’ve used the following components for my Wake-up light:

Home Assistant and Node-RED running on a Raspberry 3B+ using Hass.io
Conbee Zigbee hub; there is a USB version and a PI version. (More info here)
Three GU10 Zigbee smart lights. I use 3 Innr GU10 lights(not available in the US) but you could also use something like the lights from Philips Hue.

These components are just an example. A minimum requirement is a device that runs Home Assistant and Node-RED, and a smart light that you can control.

My Home Automation hardware setup

For controlling the settings of the wake-up light I use the same widget as with my previous post. Please see that post if you would like to read more of the details.

The system requires three inputs:

An input_boolean to enable or disable the system.
A second input_boolean to enable or disable the system on weekends.
A input_datetime to set the time of the wake-up light.

# configuration.yaml
input_boolean :
  wakeup_enabled:
    name: "Wake-up lights"
    initial: on
    icon: mdi:theme-light-dark
  wakeup_weekend:
    name: "Enable Wake-up on weekends"
    initial: off # I disable the system on default on weekends
    icon: mdi:calendar-blank

input_datetime:
  wakeup_time:
    name: "Start lights at"
    has_time: true
    has_date: false
    initial: "07:20"

Note: If you want to persist the values between restarts of Home Assistant remove the ‘initial’ value from the configuration.

The controls can be combined in a single view (or you can do this through the Lovelace ui editor):

# groups.yaml
alarm_clock:
  name: "Wake-up Lights"
  entities: # Add all entities here that should be part of the widget
    - input_datetime.wakeup_time
    - input_boolean.wakeup_enabled
    - input_boolean.wakeup_weekend

Building the flow

Scheduling

The first step in our flow is reading the wakeup_time from Home Assistant. This time is then passed on to a schedex node. The schedex node is a easy-to-use node to start something at a configurable time. An alternative is BigTimer but for something simple as this I prefer schedex. The schedex node sends a message at a specific time that can be configured. This perfectly matches our requirements as we would like to start the wake-up light at a configurable time (without changing the flow each time the time changes).

The most important node of the flow: schedex

To configure the schedex trigger, we have to send a payload with the new time to the schedex node when the wake-up time changes in Home Assistant. Schedex requires a specific payload format so I use simple function node (the parse time node in the image) to map the data from Home Assistant tot he correct format:

new_msg = {
    payload: {
        ontime: msg.payload.substr(0,5),
        offtime: msg.payload.substr(0,5)
    }
}
return new_msg;

Triggering the wake-up light is done using a schedex node.

These three nodes make sure that: 1) each time we change the wake-up time in HA the schedex node is updated and 2) the schedex node triggers a message at the configured time.

The configuration of the schedex node can be used to set some default values. I let the node send an ‘off’ message 60 minutes after the wake-up time started; you could use such an off message to run some additional automations.

Default values for the schedex node

Enable/disable the wake-up light

The wake-up light can be disabled or only enabled on week days. To implement these requirements we add a filter after the schedex node that checks if the requirements are met.

When schedex triggers an event we still need to check whether the wakeup light is enabled. This can be done by using a few nodes in series.

To implement this filter I make use of a function node that uses Javascript to get the day of the week. The node returns true as the payload if the current day is a weekend day. In Javascript ‘6’ is a Saturday and Sunday ‘0’.

// Contents of the "Day of the week" function node
var day = new Date().getDay();

var isWeekend = (day === 6) || (day === 0);

return {
    payload: isWeekend,
};

Configuration of the function node using the javascript snippet.

The output of the function node can then be routed using a switch node:

Switch node to route the output of the weekend-node.

Controlling the lights

The last step is to connect the output of the “Enabled?” node to a sequence that controls the lights. You can go wild here and create something based on the light setup in your bedroom. In my case I start the lights at 1% brightness and then slowly increase the brightness for 30 minutes. After 30 minutes, when all the lights are at max brightness, it further sets my home to a ‘morning’ state and turns on lights in other parts of the house.

In my example I use a template node to slowly increase the brightness of the lights:

{{ [250, state_attr('light.bedroom', 'brightness') + 9] | min }}

Complete flow and source code

Connecting all components and my light control nodes results in the complete flow as shown below:

The complete flow controlling my wake-up light using Node-RED.

To get started with this setup you can use the json source code of my nodes and customize them to fit your needs. At a minimum you need to change the entities of the lights that you would like to control.

Source code of nodes used in this post

[{"id":"d228445d.4259f8","type":"function","z":"556ecca6.827b14","name":"Get day of week","func":"var day = new Date().getDay();\n\nvar isWeekend = (day === 6) || (day === 0); \n\nreturn {\n    payload: isWeekend,\n};","outputs":1,"noerr":0,"x":260,"y":1420,"wires":[["ba532104.74a48"]]},{"id":"ba532104.74a48","type":"switch","z":"556ecca6.827b14","name":"Is it weekend?","property":"payload","propertyType":"msg","rules":[{"t":"true"},{"t":"else"}],"checkall":"true","repair":false,"outputs":2,"x":260,"y":1460,"wires":[["e7a99d1f.bdef"],["e25ce15f.614ee"]]},{"id":"e7a99d1f.bdef","type":"api-current-state","z":"556ecca6.827b14","name":"Enabled on weekends?","server":"161bb087.35566f","halt_if":"off","halt_if_type":"str","halt_if_compare":"is","override_topic":true,"override_payload":true,"override_data":true,"entity_id":"input_boolean.wakeup_weekend","state_type":"str","outputs":2,"x":530,"y":1420,"wires":[["e25ce15f.614ee"],[]]},{"id":"e25ce15f.614ee","type":"api-current-state","z":"556ecca6.827b14","name":"Enabled?","server":"161bb087.35566f","halt_if":"off","halt_if_type":"str","halt_if_compare":"is","override_topic":true,"override_payload":true,"override_data":true,"entity_id":"input_boolean.wakeup_enabled","state_type":"str","outputs":2,"x":480,"y":1460,"wires":[["7db42b.e3de6bd4"],[]]},{"id":"7db42b.e3de6bd4","type":"api-call-service","z":"556ecca6.827b14","name":"1%","server":"161bb087.35566f","service_domain":"light","service":"turn_on","data":"{\"entity_id\":\"light.bedroom\",\"brightness\":1}","render_data":false,"mergecontext":"","output_location":"payload","output_location_type":"msg","x":230,"y":1600,"wires":[["5f30d3cb.1aadac"]]},{"id":"5f30d3cb.1aadac","type":"looptimer","z":"556ecca6.827b14","duration":"1","units":"Minute","maxloops":"30","maxtimeout":"35","maxtimeoutunits":"Minute","name":"","x":300,"y":1640,"wires":[["de710702.9a2d98"],[]]},{"id":"de710702.9a2d98","type":"api-render-template","z":"556ecca6.827b14","name":"Get new light setting","server":"161bb087.35566f","template":"{{ [250, state_attr('light.bedroom', 'brightness') + 9] | min }}","x":360,"y":1680,"wires":[["3df7037a.2f373c"]]},{"id":"3df7037a.2f373c","type":"api-call-service","z":"556ecca6.827b14","name":"Increase light","server":"161bb087.35566f","service_domain":"light","service":"turn_on","data":"{\"entity_id\":\"light.bedroom\",\"brightness\":\"{{ payload }}\"}","render_data":true,"mergecontext":"","output_location":"payload","output_location_type":"msg","x":370,"y":1720,"wires":[[]]},{"id":"df372079.83747","type":"server-state-changed","z":"556ecca6.827b14","name":"Wake up time input","server":"161bb087.35566f","entityidfilter":"input_datetime.wakeup_time","entityidfiltertype":"substring","outputinitially":true,"state_type":"str","haltifstate":"","halt_if_type":"","halt_if_compare":"is","outputs":1,"x":230,"y":1200,"wires":[["47ca214a.cd1c1"]]},{"id":"47ca214a.cd1c1","type":"function","z":"556ecca6.827b14","name":"Parse time","func":"new_msg = {\n    payload: {\n        ontime: msg.payload.substr(0,5),\n        offtime: msg.payload.substr(0,5)\n    }\n}\nreturn new_msg;","outputs":1,"noerr":0,"x":250,"y":1280,"wires":[["cfe7b8ae.660428"]]},{"id":"cfe7b8ae.660428","type":"schedex","z":"556ecca6.827b14","name":"Trigger at time","suspended":false,"lat":"","lon":"","ontime":"7:30","ontopic":"","onpayload":"on","onoffset":0,"onrandomoffset":0,"offtime":"12:00","offtopic":"","offpayload":"off","offoffset":"60","offrandomoffset":0,"mon":true,"tue":true,"wed":true,"thu":true,"fri":true,"sat":true,"sun":true,"x":440,"y":1280,"wires":[["b361dc76.e4a18"]]},{"id":"b361dc76.e4a18","type":"switch","z":"556ecca6.827b14","name":"is on","property":"payload","propertyType":"msg","rules":[{"t":"eq","v":"on","vt":"str"}],"checkall":"true","repair":false,"outputs":1,"x":590,"y":1280,"wires":[["d228445d.4259f8"]]},{"id":"235e234a.7b2aac","type":"comment","z":"556ecca6.827b14","name":"Time setting input","info":"","x":230,"y":1160,"wires":[]},{"id":"b938cf54.1bdd3","type":"comment","z":"556ecca6.827b14","name":"Trigger at the configured time","info":"","x":480,"y":1240,"wires":[]},{"id":"5a93ca40.9dd574","type":"comment","z":"556ecca6.827b14","name":"Check if the wake-up light should be enabled on this day of the week","info":"","x":390,"y":1360,"wires":[]},{"id":"e34ba2ee.19df8","type":"comment","z":"556ecca6.827b14","name":"Run the wake-up sequence","info":"","x":260,"y":1520,"wires":[]},{"id":"161bb087.35566f","type":"server","z":"","name":"Home Assistant"}]

Questions? Feedback? Feel free to add them to the comments of this post.

Series on Home Automation

Interested in my setup?

Home Automation hardware setup

Setting color temperature and brightness of IKEA Tradfri lights simultaneously with Home Assistant

Thu, 17 Jan 2019 00:00:00 +0000

In my smart home I use multiple IKEA Tradfri lights in combination with a Conbee Zigbee hub and Home Assistant. Recently I encountered a problem when trying to set both the brightness and the color temperature in a Home Assistant service call (light.turn_on). Apparently, the Tradfri bulbs only respond to one of these values at a time. This is unfortunate as changing the temperature and brightness is usually linked. For example, setting the lights to a dimmed warm setting at night or bright white in the morning. Luckily, there is a workaround to be able to set both simultaneously (sort of at least).

The solution to setting brightness and color temp on Tradfri lights is to split the single service call in to two and let those blend. In my setup, I first set the brightness of the lights with a small transition and use a second call to change the color temperature with a longer transition. I have tested multiple setups and this method results in the smoothest transition. In essence my workaround performs three steps:

Turn on the light with the target brightness.
Delay for a second to make sure that the previous call has finished.
Set the color temperature of the light with a short transition (5 seconds).

By putting these steps in to a script it can act as a drop-in replacement of a normal light call. If one of the settings was already set earlier, for example the brightness did not change, the transition is even smoother.

I have created two versions of this workaround, one for Home Assistant (YAML) and one for Node-RED, to help others that encounter this problem. It is not the most elegant solution but in practice it works pretty good!

Home Assistant script

To use the workaround in Home Assistant (yaml) add the following snippet to scripts.yaml:

turn_on_ikea_light:
  sequence:
    # Check whether the light is off (optional)
    - condition: template
      value_template: "{{ is_state(entity, 'off') }}"
    - delay: '00:00:01'
    # Set the brightness of the lights.
    - service: light.turn_on
      data_template:
        entity_id: "{{ entity }}"
        brightness_pct: "{{ brightness_pct }}"
        transition: 1
    - delay: '00:00:01'
    # Set the color temperature.
    - service: light.turn_on
      data_template:
        entity_id: "{{ entity }}"
        color_temp: "{{ color_temp }}"
        transition: 5

This block of code adds a new script turn_on_ikea_light that can be called inside automations. entity, brightness_pct and color_temp are variables that can be set when calling the script. An example is the following automation where a light is turned on when a motion sensor registers movement:

# Example automation using the script
automation:
  - alias: Turn on lights on movement
    trigger:
      - platform: state
        entity_id: sensor.motion_sensor
        to: 'on'
    action:
      service: script.turn_on_ikea_light
      data_template:
        # Variables that are passed on to the script:
        entity: light.some_light_entity
        brightness_pct: 80
        color_temp: 350

Node-RED script

I’ve recently switched most of my automations to Node-RED so also rewrote my workaround. In Node-RED we need two service calls to HA (one for brightness and one for color temp). In the most simple case this can be done with two “call service” nodes and a delay node. To be able to reuse the flow this can be created as a subflow:

Subflow to set brightness and color temperature on Ikea lights

The subflow shown above expects a JSON message as the msg.payload. The payload is then split in to the two service calls. For example, to set the temperature of a light to 150 and the brightness to 100%, one could send the following payload:

{
    "entity_id": "light.some_light_entity",
    "color_temp": 150,
    "brightness_pct":100
}

The values can be hard coded in a change-node or can be dynamically set (for example based on the time of day).

Complete flow in Node-RED. Replace the inject node with something useful, e.g. a motion event.

The nodes of the subflow can be imported using the following snippet:

[{"id":"13593ff8.a6556","type":"api-call-service","z":"2dc416a2.d3b6fa","name":"Turn on lights","server":"161bb087.35566f","service_domain":"light","service":"turn_on","data":"{\"entity_id\":\"light.some_entity\",\"transition\":1}","render_data":false,"mergecontext":"","output_location":"payload","output_location_type":"msg","x":700,"y":480,"wires":[[]]},{"id":"7167f74f.dd6528","type":"api-call-service","z":"2dc416a2.d3b6fa","name":"Set color temp","server":"161bb087.35566f","service_domain":"light","service":"turn_on","data":"{\"transition\":5}","render_data":false,"mergecontext":"","output_location":"payload","output_location_type":"msg","x":840,"y":420,"wires":[[]]},{"id":"96a91d65.7a1a4","type":"delay","z":"2dc416a2.d3b6fa","name":"","pauseType":"delay","timeout":"1","timeoutUnits":"seconds","rate":"1","nbRateUnits":"1","rateUnits":"second","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":false,"x":680,"y":420,"wires":[["7167f74f.dd6528"]]},{"id":"b76ccf31.5d0c","type":"function","z":"2dc416a2.d3b6fa","name":"Split payload","func":"br = {\n    payload: {\n        data: {\n            entity_id: msg.payload.entity_id,\n            brightness_pct: msg.payload.brightness_pct\n        }\n    }\n}\n\nwarmth = {\n    payload: {\n        data: {\n            entity_id: msg.payload.entity_id,\n            color_temp: msg.payload.color_temp\n        }\n    }\n}\n\nreturn [warmth, br]\n","outputs":2,"noerr":0,"x":490,"y":440,"wires":[["96a91d65.7a1a4"],["13593ff8.a6556"]]},{"id":"161bb087.35566f","type":"server","z":"","name":"Home Assistant"}]

Series on Home Automation

Interested in my setup?

Home Automation hardware setup

Talking to my house: Building a chat bot with Home Assistant, AppDaemon and Telegram

Sat, 15 Dec 2018 00:00:00 +0000

Home Assistant (HA) can be easily controlled using the web interface of one of the mobile apps. However, there are more fun ways to communicate with your home. In this blog post I discuss talking (or chatting) to your home using a Telegram bot. I show how you can easily make a bot, connect it to Home Assistant and use AppDaemon to build a bot that can give you information on your home.

Best of all, using this setup you can communicate with your home even outside your local network without having to open up Home Assitant. So no port forwarding required! The Telegram bot acts as a sort of proxy between you and your HA instance.

Setting up a new Telegram bot

To start, we need to make a Telegram bot to link with HA. There is an extensive guide at the Telegram website. In essence it boils down to a few simple steps:

Start a new conversation with the BotFather. This is a special bot that can be used to manage and create bots.
Use the command /newbot to start the process of making a bot.
Fill in the name of your bot (this is the display name).
Fill in the username of your bot (this has to be in the format of bot).
When all is done you will receive a HTTP API token from the BotFather. This is required to connect the bot to HA.

Setting up a new bot with Telegram using the BotFather.

After creating your bot you can start chatting with it. Note that a user must always start a chat with a bot; a bot cannot start a conversation on its own.

Connecting a Telegram bot to Home Assistant

To start connecting our new Telegram bot to HA we need to enter our credentials for accessing the bot. We do this by adding a few lines to secrets.yaml. If you do not want to use the secrets file you can also skip this step and enter the credentials directly.


telegram_bot_key: 
telegram_bot_main_chat_id: 
telegram_bot_chat_ids:
  - 
  - : other chat ids you want your bot to communicate with>

The chat id is the unique number that identifies your Telegram account. If you do not know your chat id you can send /getid to one of the ‘id’-bots. For example the IDBot: http://telegram.me/myidbot. The list of chat ids is used to prevent other people talking to your bot.

The next step is to load the Telegram bot in HA. Do this by adding the following lines to your configuration.yaml (or to a dedicated package file):

telegram_bot:
  - platform: polling
    api_key: !secret telegram_bot_key
    allowed_chat_ids: !secret telegram_bot_chat_ids

I am using the polling method for the Telegram bot. Using this method you do not have to open up your Home Assistant instance to the outside world.

We can also link the bot to the Notify component of home assistant:

notify:
  - name: telegram
    platform: telegram
    chat_id: !secret telegram_bot_main_chat_id

Basis of an AppDaemon Telegram app

AppDaemon is a great tool for building our Telegram bot as we can leverage the flexibility of Python. Alternatively, it is also possible to build your bot totally using yaml files, but that will take a bit more effort.

Start by adding a new instance to your apps.yaml configuration for AppDaemon:

bot:
  module: telegram
  class: TelegramBot

Then create the associated python file (telegram.py). To get started, copy the following to the file to use as wireframe:

import appdaemon.plugins.hass.hassapi as hass


class TelegramBot(hass.Hass):

    def initialize(self):
        # Start listening for Telegram updates
        self.listen_event(self.receive_telegram_text, 'telegram_text')

    def receive_telegram_text(self, event_id, payload_event, *args):
      # Do something with the text
      user_id = payload_event['user_id']
      message = payload_event['text']

Save the file and the apps should automatically start. The app starts listening to telegram_text events; these are triggered when the bot receives a message.

Saying Hi!

The first feature we can build in to the bot is to say a welcome message. However, it would be kind of annoyaing if the bot said “Hi” every time we send a new message to the bot. To remedy this I only send a greeting message at most once an hour.

Extend the initialize function of the class to keep track of your conversations using a dictionary. We will store the last time a user sent a message in this dictionary.

def initialize(self):
    self.time_between_conversations = 60 * 60
    self.last_conversation = {}

A new function is added to the class that sends a greeting message. It checks whether the last message was sent longer than 60 minutes and, if so, sends a greeting message.

def greet_user_if_new_conversation(self, user_id, user_name):
    """Say hi when there is a new conversation"""

    # For new users automatically set the time to zero.
    if user_id not in self.last_conversation:
        self.last_conversation[user_id] = 0

    # Compute the time difference in seconds since the last message.
    time_diff = time.time() - self.last_conversation[user_id]

    if time_diff > self.time_between_conversations:
        msg = f"Hi {user_name}"
        # Send a message to the user.
        self.call_service('telegram_bot/send_message',
                          target=user_id,
                          message=msg)

    self.last_conversation[user_id] = time.time()

This new function is then called each time we receive a text:

def receive_telegram_text(self, event_id, payload_event, *args):
    self.log(payload_event)
    user_id = payload_event['user_id']
    message = payload_event['text']

    self.greet_user_if_new_conversation(user_id, payload_event['from_first'])

The from_first payload variable should contain your first name (if set). Saying something to your bot should now result in a simple greeting:

Simple welcome message from the bot.

Asking for the temperature

Now let’s do something usefull. I would like to keep track of the current temperature in my house. To facilitate this I created a small function that reports this. However, I only want my bot to tell me the temperature when I ask for it. So we need to do some (very simple) text parsing. I would like the bot to react to simple questions like:

Is it cold outside?

What is the temperature?

Is it warm at home?

This can be done with some ~~very advanced artificial intelligence~~ simple rules in python. The code below matches simple words in the input. Is it cold outside? matches due to cold and outside being present in the text.

if any((
    'temperature' in message,
    ('warm' in message or 'cold' in message) and ('house' in message or 'inside' in message or 'outside' in message),
    ('warm' in message or 'cold' in message) and ('house' in message or 'inside' in message or 'outside' in message),
)):
  # Report the temperature
  self.send_house_temperature(user_id)

If the text message passed any of our rules we then send the temperature back:

def send_house_temperature(self, user_id):
    """Send information about the temperature in the house"""

    sensors = {
        'The outside temperature is {} °C.': 'sensor.temp_1', # Replace this with your sensor's entity id
        'It is {} °C in the livingroom.': 'sensor.temp_2', # Replace this with your sensor's entity id
        'The temperature of the livingroom is {} °C.': 'sensor.temp_2' # Replace this with your sensor's entity id
    }

    start_messages = [
        'Let me see.',
        'These are the temperatures currently.',
        'I have read the sensors for you.'
    ]

    msg = random.choice(start_messages)
    # Read all sensors.
    for template, sensor in sensors.items():
        temp = self.get_state(sensor)
        msg += ' ' + template.format(temp)

    self.call_service('telegram_bot/send_message',
                      target=user_id,
                      message=msg)

In this new function I read out different sensors around my home. In this case measuring the outside temperature, and the temperature inside my livingroom and bedroom. A message is then constructed using a randomly chosen start sentence and the sensor readings.

A conversation with my Home Assistant bot using Telegram.

Next steps?

This tutorial gave a quick overview of making a Telegram bot, connecting it to Home Assistant and using AppDaemon to send messages. The bot can easily be extended to send other messages or perform certain tasks within Home Assistant. Maybe you want to be able to control your lights using the bot, or activate the robot vacuum cleaner. Any cool ideas? Feel free to add them in the comments!

Full code (for reference)

import time 
import random
import appdaemon.plugins.hass.hassapi as hass

class TelegramBot(hass.Hass):

    def initialize(self):
        # Start listening for Telegram updates
        self.listen_event(self.receive_telegram_text, 'telegram_text')
        
        self.time_between_conversations = 60 * 60
        self.last_conversation = {}

    def receive_telegram_text(self, event_id, payload_event, *args):
      # Do something with the text
      user_id = payload_event['user_id']
      message = payload_event['text']

      # Send greeting message.
      self.greet_user_if_new_conversation(user_id, payload_event['from_first'])

      if any((
          'temperature' in message,
          ('warm' in message or 'cold' in message) and ('house' in message or 'inside' in message or 'outside' in message),
          ('warm' in message or 'cold' in message) and ('house' in message or 'inside' in message or 'outside' in message),
      )):
        # Report the temperature
        self.send_house_temperature(user_id)

    def greet_user_if_new_conversation(self, user_id, user_name):
        """Say hi when there is a new conversation"""

        # For new users automatically set the time to zero.
        if user_id not in self.last_conversation:
            self.last_conversation[user_id] = 0

        # Compute the time difference in seconds since the last message.
        time_diff = time.time() - self.last_conversation[user_id]

        if time_diff > self.time_between_conversations:
            msg = f"Hi {user_name}"
            # Send a message to the user.
            self.call_service('telegram_bot/send_message',
                              target=user_id,
                              message=msg)

        self.last_conversation[user_id] = time.time()

    def send_house_temperature(self, user_id):
        """Send information about the temperature in the house"""

        sensors = {
            'The outside temperature is {} °C.': 'sensor.temp_1', # Replace this with your sensor's entity id
            'It is {} °C in the livingroom.': 'sensor.temp_2', # Replace this with your sensor's entity id
            'The temperature of the livingroom is {} °C.': 'sensor.temp_2' # Replace this with your sensor's entity id
        }

        start_messages = [
            'Let me see.',
            'These are the temperatures currently.',
            'I have read the sensors for you.'
        ]

        msg = random.choice(start_messages)
        # Read all sensors.
        for template, sensor in sensors.items():
            temp = self.get_state(sensor)
            msg += ' ' + template.format(temp)

        self.call_service('telegram_bot/send_message',
                          target=user_id,
                          message=msg)

Series on Home Automation

Interested in my setup?

Home Automation hardware setup

Room wake-up light: Custom room-wide wake-up light using Home Assistant

Sat, 28 Apr 2018 00:00:00 +0000

Recently I started using Home Assistant (HA) as a tool to control the lights in my home. My previous system was based on Homekit and, while working fairly good, lacked tools to further customize the automations. To get more control I switched to HA.

One of the first things I created using HA was a room wake-up light. I do own a Philips wake-up light but this doesn’t light up my whole room so that left room fore improvement. The automation I built using Home Assistant slowly lights my room every morning. The system works with any smart lamp that is compatible with HA, this includes Philips Hue] and IKEA Tradfri lamps. I use it with a few GU10 bulbs (like the Hue GU10 lights).

In this post I’ll show you how to build this system. The automation will be configurable (on/off, time) and has a switch to disable it on weekends.

More interested in Node-RED? Please read my post titled “Node-RED based custom full-room wake-up light”.

Dashboard widget of the Wake-up light component. All functions are configurable through the Home Assistant dashboard.

Example hardware

I’ve used the following components for my Wake-up light:

Home Assistant running on a Raspberry 3B+
Conbee Zigbee hub; there is a USB version and a PI version. (More info here)
Three GU10 Zigbee smart lights. I use 3 Innr GU10 lights (not available in the US) but you could also use something like the lights from Philips Hue.

These components are just an example. A minimum requirement is a device that runs Home Assistant and a smart light that you can control.

My Home Automation hardware setup

Time sensor

First step is to add a new sensor that measures time. This sensor will trigger the automation at the correct time. Add the following to sensors.yaml:

# sensors.yaml
- platform: time_date
  display_options:
    - 'time'

Make sure that this file is included in your configuration.yaml file, if not add the following:

# configuration.yaml
sensor: !include sensors.yaml

Next we build the dashboard widget. The widget consists of three controls: (1) a time input to control when the lights should go on, (2) an on/off switch and (3) a switch to enable the system on weekends.

We start with the two switches which are implemented as an input_boolean. Add the following to configuration.yaml:

# configuration.yaml
input_boolean :
  wakeup_enabled:
    name: "Wake-up lights"
    initial: on
    icon: mdi:theme-light-dark
  wakeup_weekend:
    name: "Enable Wake-up on weekends"
    initial: off # I disable the system on default on weekends
    icon: mdi:calendar-blank

The icons can be customized, see Material Design Icons for more options.

The third input controls the time of the wakeup light. For this we use input_datetime with the date component disabled as we are only interested in time.

# configuration.yaml
input_datetime:
  wakeup_time:
    name: "Start lights at"
    has_time: true
    has_date: false
    initial: "07:20"

To group the controls together in a single card on the dasboard we need to make a new group. Add the following to the groups.yaml file. Again make sure that this file is included in configuration.yaml.

# groups.yaml
alarm_clock:
  name: "Wake-up Lights"
  entities: # Add all entities here that should be part of the widget
    - input_datetime.wakeup_time
    - input_boolean.wakeup_enabled
    - input_boolean.wakeup_weekend

Note: As someone pointed out in the comments, if you want to persist the values between restarts of Home Assistant remove the ‘initial’ value from the configuration.

Create the automation

With all controls defined we can make the automation itself. The automation consists of three components: the trigger, the condition and the action. Add the following to automations.yaml:


# automations.yaml
- alias: "Wake-me up using bedroom lights"
  trigger:
    # Something that triggers the automation
  condition:
    # A list of conditions that need to be met
  action:
    # The action we want to perform.

The trigger is based on the time sensor we just created. It gets the state of the sensor and checks whether this value matches the value of our datetime input.


trigger:
  platform: template
  value_template: "{{ states('sensor.time') == (states.input_datetime.wakeup_time.attributes.timestamp | int | timestamp_custom('%H:%M', False)) }}"

The trigger we defined above will fire regardless of the on/off switches. To include the switches in the automation we have to create a list of conditions. The first condition checks whether the wake-up light is enabled, if not the automation is not executed at all. Then we add an or condition that checks whether it is a weekday (a condition on time) or that the weekend switch is enabled. Only one of the or conditions has to be met.


condition:
  - condition: state
    entity_id: input_boolean.wakeup_enabled
    state: 'on'
  - condition: or # One of the conditions below must be true
    conditions:
      - condition: state # Will be true when the switch is 'on'
        entity_id: input_boolean.wakeup_weekend
        state: 'on'
      - condition: time # Will be true on weekdays
        weekday:
          - mon
          - tue
          - wed
          - thu
          - fri

Last we define what to do when all conditions are met. In my case I slowly fade in all the lights in the group.bedroom group. You can add your own lights here.


action:
  - service: light.turn_on
    entity_id: group.bedroom # Put the entity of your light or your group here
    data:
      transition: 600 # Transition time in seconds
      brightness: 255

The full automation with everything filled in, this should be placed in automations.yaml.


# automations.yaml
- alias: "Wake me up with bedroom light transition for weekdays"
  trigger:
    platform: template
    value_template: "{{ states('sensor.time') == (states.input_datetime.wakeup_time.attributes.timestamp | int | timestamp_custom('%H:%M', False)) }}"
  condition:
    - condition: state
      entity_id: input_boolean.wakeup_enabled
      state: 'on'
    - condition: or
      conditions:
        - condition: state
          entity_id: input_boolean.wakeup_weekend
          state: 'on'
        - condition: time
          weekday:
            - mon
            - tue
            - wed
            - thu
            - fri
  action:
    - service: light.turn_on
      entity_id: group.bedroom
      data:
        transition: 600
        brightness: 255

Enable the automation

With everything filled in restart HA. The widget should be available on your dashboard. From there you can enable the widget and set a custom time. Your lights should now go on at the defined time 💡.

Series on Home Automation

Interested in my setup?

Home Automation hardware setup

home automation on Wouter Bulten

Home Automation / Home Assistant setup with recommended hardware: The four-year update

What did (not) change?

Controllers

Intel NUC

Heating

Aqara Smart Radiator Thermostat E1

Lights

Philips Hue Color GU10

Philips Hue Color E27

Philips Hue White Ambiance E27

Philips Hue White Ambience GU10

Plugs

Innr smart plug

OSRAM Smart+ Plug (Sylvania in the US)

Sensors

Philips Hue Motion Sensor

Philips Hue Motion Sensor (Outdoor)

Series on Home Automation

Interested in my setup?

Other posts in this series

Automatically turn on tv when streaming to a Chromecast

(Hardware) requirements

Flow

Source code

Series on Home Automation

Interested in my setup?

Other posts in this series

Automatic dark mode for Home Assistant

Getting a dark mode theme

Configuring users

Creating the automation

Series on Home Automation

Interested in my setup?

Other posts in this series

Local face recognition for Home Assistant using TensorFlow.js, Part 2: Learning to recognize faces

Hardware requirements

Collecting the training set

Training a face matcher

Recognizing faces

Starting the server

Adding training images on the fly

Wrap up & next steps

Series on Home Automation

Interested in my setup?

Other posts in this series

Local presence detection using face recognition and TensorFlow.js for Home Assistant, Part 1: Detection

Requirements for local face recognition

Choosing a recognition system

Hardware requirements

Part 1: Building a face detection system

Setting up the webhook

Running face detection

Speeding up recognition

Tying everything together

Series on Home Automation

Interested in my setup?

Other posts in this series

Setting up Home Automation with Docker Compose: Home Assistant, Node-RED, and more

Use of the .env file

Note on volumes

Docker compose for Home Assistant

Docker compose for Database using MariaDB

Docker compose for Zigbee hub using Deconz

Docker compose for Node-RED

Docker compose for AppDaemon

Docker compose for VS Code Server

Complete docker compose file

Series on Home Automation

Interested in my setup?

Other posts in this series

My Home Assistant Smart Home setup with hardware list

Controllers

Intel NUC

ConBee

Raspberry Pi 3B+

Dashboards

Amazon Fire Tablet

Buttons and switches

Philips Hue Smart Dimmer Switch