Loxone vs Zigbee

11 minute read  • 

Loxone vs Zigbee

Loxone has its own proprietary wireless technology called Loxone Air. Peripherals based on this technology integrate seamlessly into the Miniserver and controlling them is no different to hard-wired devices.

The problem with Loxone Air is that it is a closed technology, and the Loxone peripherals are also relatively expensive, often 2-4 times more so than their Zigbee equivalents. Not only that, but there are fair less products available compared to the vast Zigbee (and now Matter) ecosystems.

Door sensors are an example that are far cheaper in Zigbee, but others such as smart lightbulbs (Philips Hue for example) have no equivalent at all. Adding Hue bulbs to your Loxone system is a great way to retro-fit and expand smart lighting to an already established smart home.

There are a couple of options for adding Zigbee to Loxone:

  • Using a Loxberry which is based on Raspberry PI. You may choose this option if you already have a Loxberry, or if you maintain most if not all of your automation programming within Loxone.
  • Using Home Assistant. You may choose this option if you want to maintain some automation logic within HA instead of Loxone.

Both are solid options, but we’ll focus on Loxberry in this article because it’s designed specifically to work with Loxone systems. Loxberry is an impressive open-source project that is actively maintained, very well designed, secure and reliable, and gets automatic updates. Running a Loxberry alongside your Loxone requires very little support from your POV and is basically a ‘plug it in and leave it alone’ kind of option.

Bridging Zigbee networks

If you’ve got this far you’ve probably decided that you want to add some Zigbee devices to your Loxone installation. So let’s get started.

We’re going to build a Zigbee gateway using a Raspberry PI, running Loxberry, and a USB Zigbee dongle. Here’s the summary of steps involved:

  1. Setup Loxberry on a RaspberryPI.
  2. Install a Zigbee USB dongle on the PI.
  3. Install the Zigbee2MQTT plugin on your Loxberry
  4. Put Zigbee2MQTT in learning mode and add your devices!

This setup above will allow us to control Zigbee devices by sending MQTT commands from the Miniserver to our Loxberry.

Setup Loxberry on Raspberry PI

If you don’t already have a Loxberry as part of your setup, you need to source a couple of components (a PI, and an enclosure). It’s very worthwhile because there are lots and lots of plugins for Loxberry that extend the functionality of your Loxone system.

Get yourself a Raspberry PI, Head over to Loxberry and follow the installation instructions:

I really like these Vesa-compatible enclosures from The PiHut because they can be mounted onto a wall/cupboard and hidden away:

Zigbee USB Dongle

Turning your Loxberry into a Zigbee gateway is fairly straight forward. But first you’ll need to find a Zigbee USB dongle that acts at the gateway. You need to be careful to select one that is compatible with the Zigbee2MQTT project:

https://www.zigbee2mqtt.io/guide/adapters/

I use the Conbee II from DeConz and this is very stable and works extremely well. I’ve also used the Sonoff dongle which also works well.

I’ve had this setup for almost 10 years and it’s been flawless. These days, with Matter devices coming onto the market, it is worth considering a USB dongle that supports both Zigbee (for legacy devices) and also the newer Matter standard. The Conbee III looks like it might provide this, but it is early days so be careful with this emerging standard:

Whatever you decide on, plug in the Zigbee dongle to a spare USB port on your Raspberry PI (there should be 4 ports). You will need to know which port the USB dongle has been plugged into, so that Loxberry knows how to find it.

To find the port, SSH into your Loxberry and run the following command to list the devices you have plugged in:

ls -l /dev/serial/by-id/

You should get a result similar to the screenshot below:

On my Loxberry, the Conbee is attached to ttyACM0. Remember this value for when we install Zigbee2MQTT in the next step.

Install Zigbee2MQTT

Zigbee2MQTT is another well supported, open-source library that supports a very large number different Zigbee devices. The best way to use this software on Loxberry is to install the Zigbee2MQTT Loxberry plugin: https://wiki.loxberry.de/plugins/zigbee2mqtt_plugin/start

This plugin is specifically designed for Loxberry and bundles the Zigbee2MQTT software as part of the installation. Once the plugin is installed, you need to configure Zigbee2MQTT to tell it which port the dongle is attached to.

Head to the plugin page for Zigbee2Mqtt and configure the port value with the one you’ve identified with the ls command previously:

Zigbee vs Wi-Fi

One detail to take care of is specifying the Zigbee channel that your dongle will operate on. A lesser-known fact about Zigbee, is that ZigBee and Wi-Fi channels both exist in the 2.4 GHz band, and it is very possible for Zigbee to clash with Wi-Fi when they are both using channels that overlap. If you’ve hard-coded your Wi-Fi router to a specific channel, be aware of interference and reliability issues when you start introducing Zigbee into your home.

I’ve had huge problems with QMotion blinds in the past because the supplied proprietary Zigbee gateway was hard-coded to a channel that overlapped with my powerful Wi-Fi setup, and there was no way to change it (the Zigbee “Qube” gateway). Reliability issues are incredibly hard to solve but the problems almost always relate to interference. Choosing the right channel is essential to achieve a stable and reliable setup.

I’ve found that configuring Zigbee to use channel 20 works the best in my house - this channel doesn’t overlap with my Wi-Fi network and solved all issues with commands being dropped. Channels 15, 25 and 26 are also good choices.

Zigbee2MQTT allows you to configure which channel to run the Zigbee network over. Simply go to the advanced settings area (Plugins -> Zigbee2mqtt UI -> Settings -> Advanced) and there is an option to set the channel:

Joining Zigbee devices

At this point you should be good-to-go! Joining devices to your Loxberry is now trivial. Check the ‘Allow new devices’ option in Zigbee2MQTT so that new devices can be registered:

All Zigbee devices are a little different in how they pair with a gateway, so check the instructions for whatever devices you own. Most of the time though, brand new devices will pair straight away.

You will see all your devices under the Devices tab in Zigbee2Mqtt:

I always set the Friendly Name for each of my devices, just to make it easier to find them in the UI. I use a naming convention with underscores instead of spaces, to make controlling them simpler, and compatible with MQTT topic names.

You can now experiment by sending commands through the Zigbee2mqtt UI -> Exposes tab. Just click on one of the devices listed, turn them on or off, or do whatever actions the device supports.

Controlling Zigbee with MQTT

Are you ready to control your Zigbee devices with Loxone? Let’s go! MQTT is the most widespread protocol used for home automation, and it is supported out-of-the-box with Loxberry.

The diagram shows how Loxone will communicate with ZigBee devices. There are a few steps involved to make the magic happen, but it is all handled by the Loxberry plugins we’ve already installed. The key component in all of this is the MQTT message broker (Mosquito) that handles all communications.

Because Loxone is quite limited in the communication protocols it supports, we can only choose between HTTP and UDP; there is no direct support for MQTT. This is where Loxberry enters the scene, and we rely on the MQTT plugin to proxy our MQTT commands on towards the MQTT broker:

  • The built-in Loxberry MQTT plugin acts as an interface between Loxone & Mosquito, to allow Loxone to communicate indirectly with the Mosquito MQTT broker.
  • Loxone will send MQTT messages (via Loxberry), using UDP.
  • Loxone will receive MQTT messages (via Loxberry), using TCP/HTTP.
  • The Zigbee2MQTT plugin translates Zigbee protocol messages to and from the Mosquito MQTT broker.

MQTT is the standard for IoT (Internet of Things) messaging, and Loxberry has an inbuilt MQTT server since version 3.0, so it’s no longer necessary to install the MQTT plugin manually.

Since version 15.3, Loxone has limited support for MQTT on Gen2 miniservers. But there is a limit to how many inputs and outputs can be used - only 16 subscriptions as well as 16 inputs and outputs.

Controlling devices with virtual outputs

Sending an MQTT packet to Loxberry is fairly simple. First we need to create a new Virtual Output to allow us to communicate with the MQTT plugin on Loxberry:

Call the Virtual Output anything you want. I call mine Zigbee MQTT Gateway. The important detail is to specify the IP address & port where MQTT messages will be routed:

/dev/udp/192.168.1.22/11884

This setting specifies that commands will be routed using UDP, and will be sent to 192.168.1.22 (this is the address of my Loxberry), using port 11884. This is the default port configured by the Loxberry MQTT gateway, so use this value unless you’ve changed it to be something different. You will find this setting under:

Loxberry -> MQTT -> Gateway Settings -> UDP in-port

Remember that Loxone is not talking directly the MQTT message broker. Loxone does not support this protocol. Instead, your virtual output must be directed firstly to the MQTT gateway plugin on Loxberry.

Virtual Output Commands

The virtual output defines the gateway through which our MQTT commands will go. But now we need to add specific output commands to target each Zigbee device that we want to interact with.

We use the Command for ON setting to specify the MQTT message. Part of the message is the payload (in JSON format) containing the Zigbee command we want the broker to send. Here’s an example for turning our Aqara relay on using the friendly name:

publish zigbee2mqtt/aqara_relay_uility/set {"state":"ON"}

And another for turning it off, this time using the hex-coded address:

publish zigbee2mqtt/0x001788010bb9f756/set {"state":"OFF"}

Sending commands is very straight-forward.:

  • We use the publish command, specifying the MQTT topic where the message should be sent.
  • The topic in this case is zigbee2mqtt/aqara_relay_uility/set.
  • We use the friendly name of the device that we configured in Zigbee2MQTT. You can also use the hexadecimal address if you prefer.
  • The message payload is a JSON string: {"state":"OFF"}.

Each Zigbee device will have a slightly different set of capabilities, and different commands to control them. Rather than going to each manufacturer’s website to figure it out, simply visit: https://www.zigbee2mqtt.io/supported-devices/# …and search for your device. Most devices have their APIs documented there, complete with examples to get you going.

Reading sensor data with virtual inputs

Reading sensor data (such as temperature sensors or door contacts) will use a HTTP virtual input instead of UDP. Using a virtual input is a little different to the virtual output commands we used previously. There will be one virtual input for each of the messages we want to received. To create these, simply add a new virtual input to your miniserver:

The trick with receiving MQTT messages in this way, is to name the virtual inputs exactly as they appear in the MQTT gateway. To figure this out, you should first browse to MQTT -> MQTT Gateway -> Incoming Overview to see the list of messages being received by the MQTT gateway:

The column on the left lists the Miniserver Virtual Inputs that are supported. The MQTT plugin will attempt to send these to the miniserver. If you filter on the friendly name you specified for your device when it joined the network, you will find the exact set of messages that this device supports.

In our case we want to receive the humidity value, so we pick: zigbee2mqtt_aqara_temp_humidity_utility_humidity. This is the name we specify for the virtual input that will receive the value.

Configuring the virtual input

A couple of important settings are needed for the virtual input, in addition to getting the same exactly right:

  1. You probably want to receive analogue values, so uncheck the Use as digital input field.
  2. You need to grant permission for Loxberry to send the value to your input. Create a new user (Add New User) called loxberry. You will need to grant it WebApi access.
  3. Now click on the Permissions -> Authorized Users / Groups in the Virtual Input settings and ensure that the loxberry user is selected. You can check that the miniserver is receiving the value - there will be a green checkbox next to any input value that is successfully processed.

Conclusion

So far we’ve covered setting up a Loxberry to act as a Zigbee gateway, and using virtual inputs and outputs to communicate with Zigbee devices. Hopefully this is enough background information to integrate any Zigbee device into your Loxone system.