# ControllerX
ControllerX is an AppDaemon app for Home Assistant that turns button
controllers (IKEA, Philips Hue, Aqara, Tuya, etc.) into fully working
light, media player, switch and cover controllers. Each app is
configured in AppDaemon's `apps.yaml` with `module: controllerx`, a
device-specific `class` (e.g. `E1810Controller`), the `integration`
that receives the button events (z2m, deconz, zha, ...), the
`controller` ID and the entity to control (e.g. `light`). Holding a
button repeats a Home Assistant service call until it is released.
Default button mappings can be replaced with a custom `mapping`.
A machine-readable list of the supported devices, with their
controller classes and default mappings, is available at
https://xaviml.github.io/controllerx/controllers/devices.json
# Getting started
# ControllerX
*Create controller-based automations with ease to control your home devices and scenes from [Home Assistant]() (HA).*
*ControllerX* brings the following functionalities to [many controllers]():
- Turn on/off any home device (light, switch, media player, etc.)
- Manual increase/decrease of brightness and color temperature
- Smooth increase/decrease (holding a button) of brightness, color temperature, volume, etc.
- Color loop if the light supports xy color
- Play/pause music
- Open/close covers
[Get started]() [Find your controller]() [Build your configuration]()
## Why *ControllerX*?
Solutions like Zigbee2MQTT, deCONZ and ZHA have their pros and cons, but one of their benefits is that they remove the dependency on a proprietary hub (e.g. IKEA, Xiaomi, Philips). However, the proprietary hubs not only connect a controller with lights or media players, they also give them behaviour: dimming while a button is held, cycling colors, changing the volume, etc. Without the hub, we end up writing Home Assistant automations, and automations like these quickly get tricky and difficult to maintain.
This is where *ControllerX* comes in, together with AppDaemon. It brings back the behaviour that the devices lose without the original hub, and makes it easy to create automations focused on button events.
## How it works
```
flowchart LR
A["Controller
(button pressed)"] --> B["Integration
(Zigbee2MQTT, ZHA, deCONZ...)"]
B -- "action event
e.g. brightness_up_hold" --> C["ControllerX
(AppDaemon app)"]
C -- "mapping
e.g. hold_brightness_up" --> D["Home Assistant
service calls"]
D --> E["Light, media player,
switch or cover"]
```
1. When a button is pressed, the [integration]() fires an action event (e.g. `brightness_up_hold`).
2. ControllerX translates that event into a [predefined action]() (e.g. `hold_brightness_up`) using the default mapping of the device, or your own [custom mapping]().
3. ControllerX calls the Home Assistant services to change the entity. When a button is held, it keeps calling them periodically until the release event arrives, so the brightness, color or volume changes smoothly.
## Quick example
With just this configuration placed in your [`apps.yaml`](), you can have the E2002 controller from IKEA (4 buttons) connected to the living room light, and be able to change the brightness and the color temperature or color.
```
livingroom_controller:
module: controllerx
class: E2002LightController
controller: livingroom_controller
integration:
name: z2m
listen_to: mqtt
light: light.livingroom
```
> [!TIP]
>
> **Using an AI assistant?**
>
> This documentation is available in a format that AI assistants can read: [llms.txt]() (index) and [llms-full.txt]() (all the pages in one file). The list of supported devices is available as [JSON]().
## Video examples
- [E1810 (IKEA) controlling a light through MQTT]()
- [Symfonisk controlling Chromecast volume]()
- [Magic Xiaomi Cube controlling a colour light]()
- [E1810 (IKEA) controlling a colour light with ZHA]()
- [Symfonisk controlling Google Home mini]()
- [Symfonisk controlling a light]()
- [Showing the colour wheel from HA]()
- [E1743 (IKEA) button as a cover controller]()
- [E1810 (IKEA) as a TV remote]()
- [Double click for the middle button for E1810 (IKEA)]()
## Community
Thank you to all these people for sharing content related to ControllerX:
- [/u/canaletto]() - [canaletto.fr]() (French)
- [/u/jones]() - [jbetzen.net]() (German)
- [/u/fribse]() - [YouTube]() (Danish)
Questions can be asked in the following channels:
- [GitHub issue]()
- [Home Assistant Community Forum topic]()
# Installation
ControllerX is an [AppDaemon]() app, so it needs AppDaemon to run. There are two ways to install it in Home Assistant:
- [ControllerX app](<#controllerx-app-recommended>) (recommended): an app with its own AppDaemon instance and ControllerX preinstalled. ControllerX updates like any other app.
- [Manual installation](<#manual-installation>): ControllerX copied into the AppDaemon app. Use this if you already run other AppDaemon apps.
If you installed ControllerX through HACS, see [Migrating from HACS](<#migrating-from-hacs>).
## ControllerX app (recommended)
The ControllerX app runs its own AppDaemon instance with ControllerX preinstalled. Each app update brings the new ControllerX version.
> [!NOTE]
>
> **Info**
>
> The app's AppDaemon instance is meant only for ControllerX. If you already use the AppDaemon app for other apps, [install ControllerX manually](<#manual-installation>) in it instead, so you keep a single AppDaemon instance.
1. Add the ControllerX app repository to Home Assistant:
[![Add repository to Home Assistant]()]()
Or go to **Settings → Apps → App store**, select **Repositories** in the top-right menu, and add `https://github.com/xaviml/controllerx-app`.
2. Install the **ControllerX** app and start it.
3. [Configure your controllers]() in `/app_configs/d35634e3_controllerx/apps/apps.yaml`, for example with the Studio Code Server or Samba share apps. The app creates this file with a commented example on its first start. AppDaemon picks up changes to it without a restart.
The app keeps all its files in `/app_configs/d35634e3_controllerx/`:
```
/app_configs/d35634e3_controllerx/
├── appdaemon.yaml AppDaemon configuration (e.g. to enable the MQTT plugin)
├── secrets.yaml Optional, for `!secret` values
└── apps/
├── apps.yaml Your ControllerX configuration
└── controllerx/ ControllerX code, replaced on every app start
```
The `d35634e3` prefix is the one you get when adding the repository with the button or URL above. If your folder has a different prefix, look for the one ending in `_controllerx`.
To update ControllerX, update the app from **Settings → Apps**. Your files aren't changed by updates.
### Moving your configuration to the app
If ControllerX runs in the AppDaemon app today, move its configuration to the ControllerX app. The commands below run in the **Terminal & SSH** app. Set `OLD` to the folder that has your `apps.yaml`:
- `/homeassistant/appdaemon/apps` if you installed ControllerX through HACS (some tools show it as `/config/appdaemon/apps`).
- `/app_configs/a0d7b954_appdaemon/apps` if you installed it manually in the AppDaemon app's default folder.
- Install and start the ControllerX app once, so it creates its folder.
- Copy your apps:
```
OLD=/homeassistant/appdaemon/apps
cp "$OLD/apps.yaml" /app_configs/d35634e3_controllerx/apps/apps.yaml
```
If the file also has apps other than ControllerX, remove them from the copy; they stay in the AppDaemon app. Don't copy the `controllerx` folder, the app brings its own.
- If you use the [MQTT plugin](), copy its `MQTT:` section from the AppDaemon app's `appdaemon.yaml` into `plugins:` in `/app_configs/d35634e3_controllerx/appdaemon.yaml`, and add `client_id: controllerx` to it, so it doesn't clash with the AppDaemon app on the MQTT broker (see [Enable MQTT plugin]()). If you copy other settings too, **leave out the `app_dir` line**: the app always uses its own `apps` folder. Also leave out `secrets: /homeassistant/secrets.yaml`, since the app can't read the Home Assistant configuration folder.
- If your configuration uses `!secret`, copy those secrets into `/app_configs/d35634e3_controllerx/secrets.yaml`.
- Remove ControllerX from the AppDaemon app:
- If you only used AppDaemon for ControllerX, uninstall the AppDaemon app.
- Otherwise, remove the ControllerX apps from its `apps.yaml`, delete the ControllerX code with `rm -rf "$OLD/controllerx"`, and restart the AppDaemon app.
- Restart the ControllerX app and check its **Log** tab.
## Manual installation
1. Install the **AppDaemon** app from **Settings → Apps → App store** and start it once. It creates its folder in `/app_configs/a0d7b954_appdaemon/`.
2. Install the **Terminal & SSH** app, open its terminal, and run:
```
APPS=/app_configs/a0d7b954_appdaemon/apps; rm -rf "$APPS/controllerx" && mkdir -p "$APPS/controllerx" && curl -fsSL https://github.com/xaviml/controllerx/releases/latest/download/controllerx.zip -o /tmp/controllerx.zip && unzip -oq /tmp/controllerx.zip -d "$APPS/controllerx" && rm /tmp/controllerx.zip
```
This downloads the latest ControllerX release into `/app_configs/a0d7b954_appdaemon/apps/controllerx/`.
3. [Configure your controllers]() in `/app_configs/a0d7b954_appdaemon/apps/apps.yaml`.
4. Restart the AppDaemon app.
If you run AppDaemon in some other way, download [controllerx.zip]() and unzip it into a `controllerx` folder inside your AppDaemon apps folder, so that `controllerx.py` ends up in `/controllerx/controllerx.py`.
### Updating
Run the same command again and restart the AppDaemon app. It only replaces the `controllerx` folder, so your `apps.yaml` stays as it is. To know when there's a new version, you can watch the [ControllerX releases]() on GitHub (**Watch → Custom → Releases**).
## Migrating from HACS
HACS no longer supports AppDaemon apps. ControllerX installed through HACS keeps working, but it won't get updates anymore. HACS installed it in `/homeassistant/appdaemon/apps/controllerx`, next to your `apps.yaml`. Switch to one of the installation methods above:
- **Stay with the AppDaemon app:** you don't need to move anything. Update ControllerX with the [manual installation](<#manual-installation>) command, using your current folder, and restart the AppDaemon app:
```
APPS=/homeassistant/appdaemon/apps; rm -rf "$APPS/controllerx" && mkdir -p "$APPS/controllerx" && curl -fsSL https://github.com/xaviml/controllerx/releases/latest/download/controllerx.zip -o /tmp/controllerx.zip && unzip -oq /tmp/controllerx.zip -d "$APPS/controllerx" && rm /tmp/controllerx.zip
```
Keep the `app_dir: /homeassistant/appdaemon/apps` line in your `appdaemon.yaml`, it's what points AppDaemon to this folder.
- **Switch to the ControllerX app:** follow [Moving your configuration to the app](<#moving-your-configuration-to-the-app>).
> [!WARNING]
>
> Keep only one copy of ControllerX running. If the same controller is configured in both the AppDaemon app and the ControllerX app, every button press runs twice (for example, a toggle turns the light on and straight back off).
## Enabling the MQTT plugin (optional)
If you use the Zigbee2MQTT integration, [enable the MQTT plugin](), since the [Home Assistant sensor listener is deprecated]().
Once [ControllerX has been installed](), you can proceed to configure ControllerX in `apps.yaml`: `/app_configs/d35634e3_controllerx/apps/apps.yaml` with the ControllerX app, or `apps.yaml` in the AppDaemon apps folder if you installed it manually. This file follows the [AppDaemon specifications](). Each ControllerX app links one controller with one entity (or group of entities), like:
```
example_app:
module: controllerx
class:
controller:
integration:
light:
```
or:
```
example_app:
module: controllerx
class:
controller:
integration:
light:
name:
color_mode: auto | xy_color | color_temp
```
or:
```
example_app:
module: controllerx
class:
controller:
integration:
media_player:
```
or:
```
example_app:
module: controllerx
class:
controller:
integration:
switch:
```
> [!TIP]
>
> The [configuration builder]() generates this configuration for your device.
## Parameters
These are the generic app parameters for all types of controllers. The parameters specific to each controller type (light, media player, switch and cover) are described in [type configuration]().
| key | type | value | description |
| --- | --- | --- | --- |
| `module`\* | string | `controllerx` | The Python module |
| `class`\* | string | `E1810Controller` | The Python class. Check the classes for each controller on the [supported controllers]() page. |
| `controller`\* | string \| list | `sensor.controller` or `hue_switch1, hue_switch2` | The controller ID, which depends on the integration. Each integration page explains how to find it. |
| `integration`\* | string \| dict | See [here]() the available integrations. | The integration through which the device is connected to Home Assistant. |
| `actions` | list | All actions | This is a list of actions to be included and controlled by the app. To see the actions of each controller, check its page in [supported controllers](). This attribute cannot be used together with `excluded_actions`. |
| `excluded_actions` | list | Empty list | This is a list of actions to be excluded. To see which actions has each controller check the individual controller pages in [here](). This attribute cannot be used together with `actions`. |
| `action_delta` | dict \| int | 300 | This is the threshold time between the previous action and the next one (being the same action). If the time difference between the two actions is less than this attribute, then the action won't be called. I recommend changing this if you see the same action being called twice. A different `action_delta` per action can be defined in a mapping. |
| `multiple_click_delay` | int | 500 | Indicates the delay (in milliseconds) when a multiple click action should be triggered. The higher the number, the more time there can be between clicks, but there will be more delay for the action to be triggered. |
| `action_delay` | dict \| int | 0 | This can be used to set a delay to each action. By default, the delay for all actions is 0. If defining a map, the key for the map is the action and the value is the delay in seconds. Otherwise, we can set a default time like `action_delay: 10`, and this will add a delay to all actions. |
| `previous_state` | dict \| str | \- | This can be used to restrict when an action is performed depending on the previous state of the entity. This is just applicable for `state` and `z2m` (when not listening to MQTT) integrations. For example, it can be used when we want the action to be triggered only with a specific previous state. |
| `mapping` | dict | \- | This can be used to replace the behaviour of the controller and manually select what each button should be doing. By default it will ignore this parameter. Read more about it [here](). The functionality included in this attribute will remove the default mapping. |
| `merge_mapping` | dict | \- | This can be used to merge the default mapping from the controller and manually select what each button should be doing. By default it will ignore this parameter. Read more about it in [here](). The functionality included in this attribute is added on top of the default mapping. |
| `mode` | dict \| int | `single` | This defines what to do when an action is already executing. The options and the behaviour are the same as [Home Assistant automation modes]() since it is based on that. The only difference is that `queued` only queues 1 task after the one being executed. One can define a mapping for each action event with different modes. |
Integration dictionary for `integration` attribute.
| key | type | value | description |
| --- | --- | --- | --- |
| `name`\* | string | See [here]() the available integrations. | This is the integration that the device was integrated. |
In addition, you can add arguments. Each [integration]() has its own arguments.
*\* Required fields*
#### Explained with YAML
```
example_app: # It can be anything
module: controllerx
# `class` value depends on the controller you want to use
# Check the classes for each controller on the supported controllers page
# Supported controller page: https://xaviml.github.io/controllerx/controllers/
class: Controller # or E1810Controller, LightController, HueDimmerController, etc.
# `controller` value depends on the integration used (z2m, deconz, zha).
# Each integration page explains how to find it: https://xaviml.github.io/controllerx/start/integrations/
controller: livingroom_controller # or my_controller_id or 00:67:88:56:06:78:9b:3f
# `integration` is the integration used for your controller
# It can be a string (e.g. `integration: deconz`) or an object with extra arguments
# Check https://xaviml.github.io/controllerx/start/integrations/ for more info
integration:
name: z2m # or deconz, zha, state, mqtt, etc.
listen_to: mqtt
# `actions` and `excluded_actions` can be used to indicate which actions from the default mapping
# will be used or not. These 2 attributes cannot be used at the same time.
actions: # or excluded_actions. This is optional.
- toggle
- brightness_up_click
# `action_delta` is the threshold to avoid firing the same action twice
action_delta: 300 # default. This is optional.
# `multiple_click_delay` is used for the multiclick functionality
# Check https://xaviml.github.io/controllerx/advanced/multiple-clicks for more info
multiple_click_delay: 500 # default. This is optional.
# `action_delay` lets you configure delays to existing actions
action_delay: # This is optional.
toggle: 10 # This will fire `toggle` action in 10 seconds after pressed.
# `mode` allows you to define the strategy when an action is already executing
# Possible values are `single`, `restart`, `queued` and `parallel`
mode: single # default. This is optional.
# `mapping` and `merge_mapping` let you override the default behaviour of your controller.
# `merge_mapping` updates the default mapping, and `mapping` overrides it completely.
# Check https://xaviml.github.io/controllerx/advanced/ for more info
merge_mapping: # or `mapping`. This is optional.
brightness_up_click: toggle_full_brightness # use predefined actions
toggle: # or HA service calls
service: scene.turn_on
data:
entity_id: scene.my_scene
toggle$2: # These scripts will be called when toggle is fired twice within 500ms (multiple_click_delay)
- service: script.my_script
- service: script.my_script_with_arguments
data:
my_attr: test
# From here on, we can include specific attributes from type controllers like
# Light, MediaPlayer, Switch or Cover controller for example
# Check https://xaviml.github.io/controllerx/start/type-configuration for more info
light: light.my_light # or media_player, switch, cover
```
Each device supports one or more controller types, and the controller type defines what the device can control (a light, a media player, a switch or a cover).
Here you can check the specific parameters that each type of controller needs. Check the [configuration]() page for the generic parameters.
## Light controller
This controller allows the devices to control a light or a group of lights. It allows you to:
- Turn on/off light(s)
- Toggle light(s)
- Manual increase/decrease of brightness and color
- Smooth increase/decrease (holding button) of brightness and color
- Color loop changing if the light supports xy color.
| key | type | value | description |
| --- | --- | --- | --- |
| `light`\* | string \| dictionary | `group.livingroom_lights` or `light.kitchen` | The light (or group of lights) you want to control |
| `manual_steps` | int | 10 | Number of steps to go from min to max when clicking. If the value is 2 with one click you will set the light to 50% and with another one to 100%. |
| `automatic_steps` | int | 10 | Number of steps to go from min to max when holding a button (smooth functionality). |
| `min_brightness` | int | 1 | The minimum brightness to set to the light. |
| `max_brightness` | int | 255 | The maximum brightness to set to the light. |
| `min_white_value` | int | 1 | The minimum white value to set to the light. |
| `max_white_value` | int | 255 | The maximum white value to set to the light. |
| `min_color_temp` | int | 153 | The minimum color temperature to set to the light. |
| `max_color_temp` | int | 500 | The maximum color temperature to set to the light. |
| `smooth_power_on` | boolean | False | If `True` the associated light will be set to minimum brightness when brightness up is clicked or held and the light is off. |
| `delay` | int | [Controller specific]() | Delay in milliseconds between the instructions sent to the light when holding a button (smooth functionality). If it is set to 0, you might get unexpected behavior. |
| `max_loops` | int | 50 | Maximum number of loops when holding. The loop will stop either with a release action or reaching the `max_loops` value. |
| `hold_release_toggle` | boolean | False | If `true`, a `hold` action will work as a release when another `hold` is running. This is useful when you have a button with just one action event and you want to use the hold-release feature, then you just need to map that event to a `hold` action. |
| `release_delay` | float | 0 | `release` actions will be delayed this amount of time (in seconds). This is to avoid cases where `release` is sent almost at the same time as `hold` actions. |
| `transition` | int | 300 | Time in milliseconds the light takes to transition from one state to another. |
| `add_transition` | boolean | True | If `true` adds transition if supported, otherwise it does not add the `transition` attribute. |
| `add_transition_turn_toggle` | boolean | True | If `false` does not add transition when turning on/off or toggling, otherwise it adds the `transition` attribute to the call. See [FAQ \#6]() for a further explanation on the use of this parameter. |
| `color_wheel` | string \| list | `default_color_wheel` | It defines the color wheel used when changing the xy color with click or hold actions. See the options below. |
| `supported_features` | int | `0b101100` or `44` | See [below](<#supported_features-field>) for the explanation. |
| `supported_color_modes` | list | `["xy", "rgb"]` | It overrides the `supported_color_modes` that can be found in light attributes. Values can be `color_temp`, `hs`, `xy`, `rgb`, `rgbw` and `rgbww`. |
| `update_supported_features` | boolean | False | If `true`, it will check the supported features field every time before calling any call service action. Useful in case the supported features of the device entity changes over time. |
| `hold_toggle_direction_init` | string | `up` | It indicates the first direction of the hold toggle actions (`up` or `down`). |
*\* Required fields*
*Light dictionary for the `light` attribute:*
| key | type | value | description |
| --- | --- | --- | --- |
| `name`\* | string | `light.kitchen` | The light (or group of lights) you want to control |
| `color_mode` | string | `auto` | This attribute can take `auto`, `xy_color` or `color_temp` as value. `auto` will check first if the light supports `xy_color` and then `color_temp`. `xy_color` will cycle through different colors infinitely. `color_temp` will change the color temperature attribute of the light. If a light supports both, you can pick which one to use for the light(s). |
*\* Required fields*
*Information about `color_wheel` attribute:*
This attribute can be either a string or a list. These are the possible string values:
| value | description |
| --- | --- |
| `default_color_wheel` | These are the 24 colors that appear in the Home Assistant color wheel. |
| `color_temp_wheel` | These are the xy colors translated from color temperature (2000K to 6488K). They were extracted from [here](). |
Otherwise, a custom xy color list can be defined like the following:
```
example_app:
module: controllerx
class: < device class or LightController >
controller: < your controller id >
integration: < your integration >
light: light.your_light
color_wheel:
- [0.525, 0.411]
- [0.167, 0.338]
- [0.324, 0.329]
```
## Zigbee2MQTT Light controller
This controller (`Z2MLightController`) allows the devices to control Zigbee2MQTT lights. It allows you to:
- Turn on/off light
- Toggle light
- Manual increase/decrease of brightness and color
- Smooth increase/decrease (holding button) of brightness and color
You can read more about this specific controller [here]().
| key | type | value | description |
| --- | --- | --- | --- |
| `light`\* | string \| dictionary | `my_light` | The light you want to control. This is the Zigbee2MQTT friendly name of the light. |
| `click_steps` | float | 70 | Number of steps that are passed to Zigbee2MQTT for click actions. |
| `hold_steps` | float | 70 | Number of steps that are passed to Zigbee2MQTT for hold actions. |
| `transition` | float | 0.5 | Transition sent to Zigbee2MQTT when changing brightness or color temp. |
| `use_onoff` | bool | `false` | This allows click and hold actions to turn on/off the light when off or minimum brightness is reached. |
*\* Required fields*
*Light dictionary for the `light` attribute:*
| key | type | value | description |
| --- | --- | --- | --- |
| `name`\* | string | `my_light` | The light you want to control. This is the Zigbee2MQTT friendly name of the light. |
| `mode` | string | `ha` | This attribute can take `ha` or `mqtt`. On the one hand, `ha` will send the mqtt messages through Home Assistant with [`mqtt.publish` service](). On the other hand, `mqtt` will send the MQTT messages through MQTT plugin from AppDaemon (hence skipping HA). |
| `topic_prefix` | string | `zigbee2mqtt` | MQTT base topic for Zigbee2MQTT MQTT messages. The topic sent will be `//set`. |
*\* Required fields*
## Media player controller
This allows you to control media players. It supports volume, play/pause and skipping forward/backward the track and the source.
| key | type | value | description |
| --- | --- | --- | --- |
| `media_player`\* | string | `group.livingroom_speakers` or `media_player.bedroom_speaker` | The media player (or group of media players) you want to control |
| `volume_steps` | int | 10 | Number of steps to go from min to max when clicking or holding. If the value is 2 with one click you will set the volume to 50% and with another one to 100%. |
| `delay` | int | [Controller specific]() | Delay in milliseconds between the volume up/down instructions when holding a button. The maximum value is 1000, and if it is set to 0, you might get unexpected behavior. |
| `max_loops` | int | 50 | Maximum number of loops when holding. The loop will stop either with a release action or reaching the `max_loops` value. |
| `hold_release_toggle` | boolean | False | If `true`, a `hold` action will work as a release when another `hold` is running. This is useful when you have a button with just one action event and you want to use the hold-release feature, then you just need to map that event to a `hold` action. |
| `release_delay` | float | 0 | `release` actions will be delayed this amount of time. This is to avoid cases where `release` is sent almost at the same time as `hold` actions. |
| `supported_features` | int | `0b10111111` or `191` | See [below](<#supported_features-field>) for the explanation. |
| `update_supported_features` | boolean | False | If `true`, it will check the supported features field every time before calling any call service action. Useful in case the supported features of the device entity changes over time. |
*\* Required fields*
## Switch controller
This allows you to control `switch` entities as well as `input_boolean` and `binary_sensor`. It supports turning on/off and toggling.
| key | type | value | description |
| --- | --- | --- | --- |
| `switch`\* | string | `group.switches` or `switch.dishwasher` | The switch (or group of switches) you want to control |
*\* Required fields*
## Cover controller
This allows you to control covers. It supports opening, closing and stopping covers.
| key | type | value | description |
| --- | --- | --- | --- |
| `cover`\* | string | `group.all_covers` or `cover.kitchen` | The cover (or group of covers) you want to control |
| `open_position` | number | 100 | The open position (between 0 and 100) |
| `close_position` | number | 0 | The close position (between 0 and 100) |
| `cover_duration` | number | \- | Duration of the cover to open and/or close in seconds, so `toggle_open` and `toggle_close` can stop the cover if the cover is still moving. This is recommended to be used when the cover does not report `opening` and `closing` states, otherwise, it is not necessary. |
| `supported_features` | int | `0b10111111` or `191` | See [below](<#supported_features-field>) for the explanation. |
| `update_supported_features` | boolean | False | If `true`, it will check the supported features field every time before calling any call service action. Useful in case the supported features of the device entity changes over time. |
*\* Required fields*
### "supported\_features" field
This field will override the `supported_features` attribute from the entity (light, media player, etc). By default, ControllerX will check this value from Home Assistant, however, sometimes this attribute does not properly reflect the features that the entity supports. ControllerX automatically selects one action or another depending on this value, so it is important that it reflects the supported features. This is defined as a bit field in Home Assistant, so the binary representation of the number defines which features it supports. You can see the values for each entity below.
#### Light
| feature | value |
| --- | --- |
| EFFECT | 4 |
| FLASH | 8 |
| TRANSITION | 32 |
If you want to express support for everything, the value is `0b101100` or `44`.
#### Media player
| feature | value |
| --- | --- |
| PAUSE | 1 |
| SEEK | 2 |
| VOLUME\_SET | 4 |
| VOLUME\_MUTE | 8 |
| PREVIOUS\_TRACK | 16 |
| NEXT\_TRACK | 32 |
| TURN\_ON | 128 |
| TURN\_OFF | 256 |
| PLAY\_MEDIA | 512 |
| VOLUME\_STEP | 1024 |
| SELECT\_SOURCE | 2048 |
| STOP | 4096 |
| CLEAR\_PLAYLIST | 8192 |
| PLAY | 16384 |
| SHUFFLE\_SET | 32768 |
| SELECT\_SOUND\_MODE | 65536 |
| SUPPORT\_BROWSE\_MEDIA | 131072 |
| SUPPORT\_REPEAT\_SET | 262144 |
| SUPPORT\_GROUPING | 524288 |
If you want to express support for everything, the value is `0b1111111111110111111` or `524223`.
#### Cover
| feature | value |
| --- | --- |
| OPEN | 1 |
| CLOSE | 2 |
| SET\_COVER\_POSITION | 4 |
| STOP | 8 |
| OPEN\_TILT | 16 |
| CLOSE\_TILT | 32 |
| STOP\_TILT | 64 |
| SET\_TILT\_POSITION | 128 |
If you want to express support for everything, the value is `0b11111111` or `255`.
# Configuration builder
Choose your device, what you want to control with it and the integration that receives its events. Then, copy the configuration into your [`apps.yaml`]().
The configuration builder needs JavaScript. You can build the configuration by hand following the steps below.
## How the configuration is built
Every ControllerX app in `apps.yaml` links one controller with one entity, and it has the following shape:
```
livingroom_controller: # (1)!
module: controllerx
class: E1810Controller # (2)!
integration: # (3)!
name: z2m
listen_to: mqtt
controller: livingroom_remote # (4)!
light: light.livingroom # (5)!
```
1. A unique name for the app. It can be anything, but each app needs a different one.
2. The controller class. It depends on the device and on what you want to control (light, media player, switch, cover...). Find it in the page of your device in [supported controllers]().
3. The [integration]() that receives the events from the device (Zigbee2MQTT, deCONZ, ZHA, etc.).
4. The controller ID. Each integration page explains how to find it.
5. The entity to control. The parameter name depends on the controller type: `light`, `media_player`, `switch` or `cover`. Read more in [type configuration]().
The rest of the parameters are optional and are described in [configuration]() and [type configuration]().
# Integrations
This integration (**`deconz`**) listens to `deconz_event` events, and the action is taken by default from the `event` attribute of the `data` object. You can change the attribute that contains the action with the `type` parameter. In addition, you can select which attribute identifies the controller (`id` or `unique_id`) with `listen_to`.
## Parameters
| Parameter | Description | Default |
| --- | --- | --- |
| `name`\* | Integration name. | `deconz` |
| `listen_to` | Attribute that identifies the controller (`id` or `unique_id`). | `id` |
| `type` | Attribute that contains the action. | `event` |
*\* Required fields*
## How to extract the `controller` attribute
To find the controller ID for deCONZ, go to `Developer Tools > Events`, subscribe to `deconz_event` at the bottom of the page and start listening. Then, press any button on the controller and copy the `id` from the `data` object of the event.
## Example
```
example_app:
module: controllerx
class: MFKZQ01LMLightController
controller: magic_cube
integration:
name: deconz
listen_to: unique_id # defaults to `id`
type: gesture # defaults to `event`
light: light.example_light
```
The `event` integration is meant to be used with any custom Home Assistant event, so it is not tied to a specific integration.
## Parameters
| Parameter | Description | Default |
| --- | --- | --- |
| `name`\* | Integration name. | `event` |
| `event_type`\* | The event we are listening to (e.g. `zha_event`). | `-` |
| `controller_key`\* | The attribute of the controller to listen to (e.g. `device_ieee`). | `-` |
| `action_template`\* | The action template that will be built from the event data (e.g. `action_{command}`). | `-` |
*\* Required fields*
### How to extract the `controller` attribute
To find the controller ID for Event, go to `Developer Tools > Events`, subscribe to the event type you are interested in at the bottom of the page and start listening. Then, press any button on the controller and copy the relevant attribute from the `data` object of the event.
For further explanation and examples, check [here]().
This integration ([**`homematic`**]()) listens to `homematic.keypress` events. It creates an action like `_`. It does not have any additional arguments.
## Parameters
| Parameter | Description | Default |
| --- | --- | --- |
| `name`\* | Integration name. | `homematic` |
*\* Required fields*
## How to extract the `controller` attribute
To find the controller ID for Homematic, go to `Developer Tools > Events`, subscribe to `homematic.keypress` at the bottom of the page and start listening. Then, press any button on the controller and copy the `name` from the `data` object of the event.
Integrations abstract how ControllerX receives the events from the controllers. Each integration is responsible for listening to a state, an event or an MQTT topic, and for decoding the controller events into actions that ControllerX understands.
These are the integrations supported by ControllerX.
### Integrations with mappings
These integrations have a default mapping for specific controllers (see [supported controllers]()).
| Integration | Configuration value |
| --- | --- |
| [Zigbee2MQTT]() | `z2m` |
| [deCONZ]() | `deconz` |
| [ZHA]() | `zha` |
| [Homematic]() | `homematic` |
| [Lutron Caséta]() | `lutron_caseta` |
| [Shelly]() | `shelly` |
| [Shelly for HASS]() | `shellyforhass` |
| [Tasmota]() | `tasmota` |
### Custom integrations
These integrations do not have a default mapping, so they are meant to be used with a [custom mapping]().
| Integration | Configuration value |
| --- | --- |
| [State]() | `state` |
| [MQTT]() | `mqtt` |
| [Event]() | `event` |
## Example
The integration name can be placed directly in the `integration` parameter:
```
example_app:
module: controllerx
...
integration: z2m
...
```
Or in the `name` parameter inside `integration`, in case you want to add other integration parameters:
```
example_app:
module: controllerx
...
integration:
name: z2m
listen_to: mqtt
...
```
This integration (**`lutron_caseta`**) listens to `lutron_caseta_button_event` events. It creates an action like `button__`. It does not have any additional arguments.
## Parameters
| Parameter | Description | Default |
| --- | --- | --- |
| `name`\* | Integration name. | `lutron_caseta` |
*\* Required fields*
## How to extract the `controller` attribute
To find the controller ID for Lutron Caséta, go to `Developer Tools > Events`, subscribe to `lutron_caseta_button_event` at the bottom of the page and start listening. Then, press any button on the controller and copy the `serial` from the `data` object of the event.
This integration (**`mqtt`**) listens to the MQTT topic set in the `controller` attribute. Although this integration is meant to be used with a [custom mapping](), it also works with the actions from Zigbee2MQTT.
ControllerX listens directly to MQTT rather than to Home Assistant. Not only can you use this with Zigbee2MQTT, but also with any other MQTT integration. This works for JSON and non-JSON payloads. If a specific attribute needs to be extracted from a JSON payload, the `key` parameter (which works like `action_key` in the Zigbee2MQTT integration) can be used.
## Parameters
| Parameter | Description | Default |
| --- | --- | --- |
| `name`\* | Integration name. | `mqtt` |
| `key` | The key to retrieve the data from. | `-` |
*\* Required fields*
## How to extract the `controller` attribute
For MQTT, the `controller` attribute is the MQTT topic to listen to. Unless `key` is set, the payload of the topic must contain the action name directly, not JSON. This means that when using the MQTT integration with a Zigbee2MQTT controller, the topic to listen to must be `zigbee2mqtt//action` or `zigbee2mqtt//click`. You can see the topics in the Zigbee2MQTT logs.
## Example
```
example_app:
module: controllerx
class: LightController
controller:
- zigbee2mqtt/stairway_sensor01_occupancy
- zigbee2mqtt/stairway_sensor02_occupancy
light: light.stairway
integration:
name: mqtt
key: occupancy
mapping:
"true": "on"
"false": "off"
```
This example turns on the light when the following payload is published to one of the 2 topics in the `controller` key:
```
{
"battery": 99,
"illuminance": 0,
"illuminance_lux": 0,
"linkquality": 255,
"occupancy": true,
"temperature": 27,
"voltage": 2985
}
```
Without `key`, the integration reads non-JSON payloads. Last but not least, the [MQTT plugin needs to be enabled]().
This integration ([**`shelly`**]()) listens to `shelly.click` events. It creates an action like `_`. It does not have any additional arguments.
## Parameters
| Parameter | Description | Default |
| --- | --- | --- |
| `name`\* | Integration name. | `shelly` |
*\* Required fields*
## How to extract the `controller` attribute
To find the controller ID for Shelly, go to `Developer Tools > Events`, subscribe to `shelly.click` at the bottom of the page and start listening. Then, press any button on the controller and copy the `device` from the `data` object of the event. You can read more about the event [here]().
This integration ([**`shellyforhass`**]()) listens to `shellyforhass.click` events. It creates an action like ``. It does not have any additional arguments.
## Parameters
| Parameter | Description | Default |
| --- | --- | --- |
| `name`\* | Integration name. | `shellyforhass` |
*\* Required fields*
## How to extract the `controller` attribute
To find the controller ID for Shelly for HASS, go to `Developer Tools > Events`, subscribe to `shellyforhass.click` at the bottom of the page and start listening. Then, press any button on the controller and copy the `entity_id` from the `data` object of the event. You can read more about the event [here]().
This integration (**`state`**) listens to the state changes of an entity, and the new state is used as the action. Add the `attribute` parameter if you want to listen to the changes of an attribute instead. Read more about the options [here]().
## Parameters
| Parameter | Description | Default |
| --- | --- | --- |
| `name`\* | Integration name. | `state` |
| `attribute` | The attribute to listen to for state changes. | `-` |
*\* Required fields*
## How to extract the `controller` attribute
To find the controller ID for State, go to `Developer Tools > States` and find the entity ID of the sensor you want to use.
## Example
Listening for the attribute `click` from the sensor `sensor.my_custom_button`:
```
example_app:
module: controllerx
class: LightController
controller: sensor.my_custom_button
integration:
name: state
attribute: click
light: light.example_light
mapping:
1_click: "on"
2_click: "off"
```
This integration ([**`tasmota`**]()) listens to the MQTT topic set in the `controller` attribute, and gets the action from the attribute defined in `component`.
## Parameters
| Parameter | Description | Default |
| --- | --- | --- |
| `name`\* | Integration name. | `tasmota` |
| `component`\* | The component we are listening to (e.g. `Button1`). | `-` |
| `key` | The key to retrieve the data from. | `Action` |
*\* Required fields*
For this integration to work, SetOption73 (for Buttons) and SetOption114 (for Switches) need to be set in Tasmota.
Tasmota payload:
```
{
"Button1": {
"Action": "TOGGLE"
}
}
```
## How to extract the `controller` attribute
The Tasmota integration relies on the [MQTT plugin](), so the `controller` is the MQTT topic to listen to (e.g. `stat/tasmota_device/RESULT`).
## Example
```
example_app:
module: controllerx
class: TasmotaButtonLightController
controller: stat/tasmota_device/RESULT
integration:
name: tasmota
component: Button1
light: light.example_light
```
This integration (**`zha`**) listens to `zha_event` events and builds the action by concatenating the command with its arguments. It does not have any additional arguments.
## Parameters
| Parameter | Description | Default |
| --- | --- | --- |
| `name`\* | Integration name. | `zha` |
*\* Required fields*
## How to extract the `controller` attribute
To find the controller ID for ZHA, go to `Developer Tools > Events`, subscribe to `zha_event` at the bottom of the page and start listening. Then, press any button on the controller and copy the `device_ieee` from the `data` object of the event. It looks like `00:67:88:56:06:78:9b:3f`.
This integration (**`z2m`**) is meant to be used with Zigbee2MQTT. It can listen to MQTT topics directly (`listen_to: mqtt`, recommended), to Home Assistant event entities (`listen_to: event`) or to the deprecated Home Assistant action sensors (`listen_to: ha`).
## Parameters
| Parameters | Description | Default |
| --- | --- | --- |
| `name` | Integration name | `z2m` |
| `listen_to` | Indicates whether it listens for HA states (`ha`), MQTT topics (`mqtt`) or HA Event state (`event`). | `ha` |
| `action_key` | The key inside the topic payload that contains the fired action from the controller. | `action` |
| `action_group` | A list of allowed action groups for the controller configuration. | `-` |
| `topic_prefix` | MQTT base topic for Zigbee2MQTT MQTT messages. | `zigbee2mqtt` |
## How to extract the `controller` attribute
### MQTT topics `listen_to: mqtt`
> [!NOTE]
>
> This option requires [enabling the MQTT plugin]().
This is the recommended option. The `controller` attribute is the friendly name of the controller in Zigbee2MQTT, which can be found in the Zigbee2MQTT configuration of the device.
For example, if the MQTT topic is `zigbee2mqtt/livingroom_controller`, the friendly name (and `controller` attribute) of the controller would be `livingroom_controller`.
### Event state `listen_to: event`
> [!NOTE]
>
> This option requires enabling `experimental_event_entities` in Zigbee2MQTT. This can be done in Zigbee2MQTT `Settings > Home Assistant integration`. Then enable `Home Assistant experimental event entities`. Note that this option is experimental since Zigbee2MQTT 2.0.
To find the controller ID for Zigbee2MQTT, go to `Settings > Devices & services > MQTT` and select the controller. The parameter you need is the entity ID of the action event without the `event.` prefix. E.g. if the event is `event.livingroom_controller_action`, the `controller` attribute should be `livingroom_controller_action`.
### HA States (`listen_to: ha`, deprecated)
> [!WARNING]
>
> This option is deprecated since ControllerX v4.29.0.
> [!NOTE]
>
> This option requires enabling `legacy_action_sensor` in Zigbee2MQTT. This can be done in Zigbee2MQTT `Settings > Home Assistant integration`. Then enable `Home Assistant legacy action sensors`. Note that this option is deprecated since Zigbee2MQTT 2.0 and will be removed in the future.
To find the controller ID for Zigbee2MQTT, go to `Settings > Devices & services > MQTT` and select the controller. The parameter you need is the entity ID of the sensor that by default finishes in `_action`.
## Example
Imagine we have the following configuration already created for a `z2m` controller listening to the (deprecated) HA state:
```
livingroom_controller:
module: controllerx
class: E1810Controller
controller: sensor.livingroom_controller_action
integration:
name: z2m
listen_to: ha
light: light.bedroom
```
Then, if we want to listen to the MQTT topic directly (skipping the HA state machine), we need to change it to:
```
livingroom_controller:
module: controllerx
class: E1810Controller
controller: livingroom_controller
integration:
name: z2m
listen_to: mqtt
action_key: action # `action` by default
light: light.bedroom
```
# Supported controllers
# Supported controllers
ControllerX supports **72** devices out of the box. Select your device to see its default button mapping and an example configuration, or use the [configuration builder]() to generate the configuration for it.
If your device is not listed, you can still use it with a [custom mapping]() on top of the generic controllers (`LightController`, `MediaPlayerController`, `SwitchController`, `CoverController` and `Z2MLightController`).
> [!TIP]
>
> **For tools and AI assistants**
>
> This list is also available as [JSON](), including the controller classes and the default mapping of every device.
All manufacturers ADEO Aqara Aurora Homematic IKEA Legrand Linkind Livarno Lutron Müller Licht Namron OSRAM Philips Prolight RGB Genie ROBB Sengled Shelly Smartkontakten SmartThings SONOFF Tasmota Terncy Trust Tuya All integrations Zigbee2MQTT deCONZ ZHA State Lutron Caseta Homematic Shelly ShellyForHass Tasmota All controller types Light Zigbee2MQTT Light Media Player Switch Cover
| Picture | Device | Manufacturer | Controller types | Integrations |
| --- | --- | --- | --- | --- |
| ![ADEO HRC99CZC045]() | [AdeoHRC99CZC045]() | ADEO | Light, Zigbee2MQTT Light | Zigbee2MQTT |
| ![Aurora AUA1ZBR2GW]() | [AUA1ZBR2GW]() | Aurora | Light | ZHA |
| ![IKEA E1743]() | [E1743]() | IKEA | Light, Zigbee2MQTT Light, Media Player, Switch, Cover | Zigbee2MQTT, deCONZ, ZHA |
| ![IKEA E1744]() | [E1744]() | IKEA | Light, Zigbee2MQTT Light, Media Player | Zigbee2MQTT, deCONZ, ZHA |
| ![IKEA E1766]() | [E1766]() | IKEA | Light, Zigbee2MQTT Light, Switch, Cover | Zigbee2MQTT, deCONZ, ZHA |
| ![IKEA E1810]() | [E1810]() | IKEA | Light, Zigbee2MQTT Light, Media Player | Zigbee2MQTT, deCONZ, ZHA |
| ![IKEA E1812]() | [E1812]() | IKEA | Light, Zigbee2MQTT Light, Switch | Zigbee2MQTT, deCONZ, ZHA |
| ![Sengled E1EG7F]() | [E1EG7F]() | Sengled | Light, Zigbee2MQTT Light | Zigbee2MQTT, ZHA |
| ![IKEA E2002]() | [E2002]() | IKEA | Light, Zigbee2MQTT Light, Media Player | Zigbee2MQTT, deCONZ, ZHA |
| ![IKEA E2123]() | [E2123]() | IKEA | Media Player | Zigbee2MQTT, deCONZ, ZHA |
| ![IKEA E2201]() | [E2201]() | IKEA | Light, Zigbee2MQTT Light, Media Player, Switch, Cover | Zigbee2MQTT, deCONZ, ZHA |
| ![IKEA E2213]() | [E2213]() | IKEA | Light, Zigbee2MQTT Light | Zigbee2MQTT |
| ![Livarno HG06323]() | [HG06323]() | Livarno | Light, Zigbee2MQTT Light | Zigbee2MQTT, ZHA |
| ![Homematic HMPB2WM552]() | [HMPB2WM552]() | Homematic | Light | Homematic |
| ![Homematic HMPB6WM55]() | [HMPB6WM55]() | Homematic | Light | Homematic |
| ![Homematic HMPBI4FM]() | [HMPBI4FM]() | Homematic | Light | Homematic |
| ![Homematic HMSenMDIRWM55]() | [HMSenMDIRWM55]() | Homematic | Light | Homematic |
| ![Philips HueDimmer]() | [HueDimmer]() | Philips | Light, Zigbee2MQTT Light | Zigbee2MQTT, deCONZ, ZHA |
| ![Philips HueSmartButton]() | [HueSmartButton]() | Philips | Light, Zigbee2MQTT Light | Zigbee2MQTT, deCONZ |
| ![IKEA ICTCG1]() | [ICTCG1]() | IKEA | Light, Zigbee2MQTT Light, Media Player | Zigbee2MQTT, deCONZ, ZHA |
| ![Legrand 600083]() | [Legrand600083]() | Legrand | Light, Zigbee2MQTT Light | Zigbee2MQTT, ZHA |
| ![Legrand 600088]() | [Legrand600088]() | Legrand | Light, Zigbee2MQTT Light | Zigbee2MQTT, ZHA |
| ![Lutron PJ22B]() | [LutronPJ22B]() | Lutron | Light, Media Player | State, Lutron Caseta |
| ![Lutron PJ22BRL]() | [LutronPJ22BRL]() | Lutron | Light, Media Player | State |
| ![Lutron PJ23BRL]() | [LutronPJ23BRL]() | Lutron | Light, Media Player | State, Lutron Caseta |
| ![Lutron PJ24B]() | [LutronPJ24B]() | Lutron | Light, Media Player | State |
| ![Lutron LZL4BWHL01]() | [LZL4BWHL01]() | Lutron | Light | deCONZ, ZHA |
| ![Aqara MFKZQ01LM]() | [MFKZQ01LM]() | Aqara | Light | Zigbee2MQTT, deCONZ, ZHA |
| ![Müller Licht MLI404002]() | [MLI404002]() | Müller Licht | Light, Zigbee2MQTT Light | Zigbee2MQTT, ZHA |
| ![Müller Licht MLI404011]() | [MLI404011]() | Müller Licht | Light, Zigbee2MQTT Light | Zigbee2MQTT, deCONZ |
| ![Namron 4512773]() | [Namron4512773]() | Namron | Light, Zigbee2MQTT Light | Zigbee2MQTT |
| ![OSRAM AC025XX00NJ]() | [OsramAC025XX00NJ]() | OSRAM | Light | deCONZ, ZHA |
| ![Philips 929002398602]() | [Philips929002398602]() | Philips | Light, Zigbee2MQTT Light | Zigbee2MQTT, deCONZ, ZHA |
| ![Philips 929003017102]() | [Philips929003017102]() | Philips | Light, Zigbee2MQTT Light | Zigbee2MQTT, deCONZ, ZHA |
| ![Philips RDM002]() | [PhilipsRDM002]() | Philips | Light, Zigbee2MQTT Light | Zigbee2MQTT |
| ![Prolight 5412748727388]() | [Prolight5412748727388]() | Prolight | Light, Zigbee2MQTT Light | Zigbee2MQTT |
| ![Philips PTM215X]() | [PTM215X]() | Philips | Light | Zigbee2MQTT, deCONZ |
| ![ROBB ROB2000070]() | [ROB2000070]() | ROBB | Light, Zigbee2MQTT Light | Zigbee2MQTT |
| ![Shelly 25]() | [Shelly25]() | Shelly | Light | Shelly |
| ![Shelly Dimmer2]() | [ShellyDimmer2]() | Shelly | Light | Shelly |
| ![Shelly I3]() | [ShellyI3]() | Shelly | Light | ShellyForHass |
| ![Shelly PlusI4]() | [ShellyPlusI4]() | Shelly | Light | Shelly |
| ![Smartkontakten SK5700002228949]() | [SK5700002228949]() | Smartkontakten | Light | deCONZ |
| ![SmartThings Button]() | [SmartThingsButton]() | SmartThings | Light, Media Player | Zigbee2MQTT, deCONZ, ZHA |
| ![SONOFF SNZB01]() | [SNZB01]() | SONOFF | Light | Zigbee2MQTT, ZHA |
| ![Tasmota Button]() | [TasmotaButton]() | Tasmota | Light, Zigbee2MQTT Light, Switch, Cover | Tasmota |
| ![Tasmota Switch]() | [TasmotaSwitch]() | Tasmota | Light, Zigbee2MQTT Light, Switch, Cover | Tasmota |
| ![Terncy PP01]() | [TerncyPP01]() | Terncy | Light | ZHA |
| ![Terncy SD01]() | [TerncySD01]() | Terncy | Light, Media Player | ZHA |
| ![Tuya TS0042]() | [TS0042]() | Tuya | Light | ZHA |
| ![Tuya TS0043]() | [TS0043]() | Tuya | Light, Cover | Zigbee2MQTT, ZHA |
| ![Tuya TS0044]() | [TS0044]() | Tuya | Light | Zigbee2MQTT |
| ![Tuya TS0044F]() | [TS0044F]() | Tuya | Light | Zigbee2MQTT |
| ![Tuya ERS10TZBVKAA]() | [TuYaERS10TZBVKAA]() | Tuya | Light, Zigbee2MQTT Light, Media Player | Zigbee2MQTT, ZHA |
| ![Aqara WXCJKG11LM]() | [WXCJKG11LM]() | Aqara | Light, Zigbee2MQTT Light | Zigbee2MQTT, deCONZ |
| ![Aqara WXCJKG12LM]() | [WXCJKG12LM]() | Aqara | Light, Zigbee2MQTT Light | Zigbee2MQTT, ZHA |
| ![Aqara WXCJKG13LM]() | [WXCJKG13LM]() | Aqara | Light, Zigbee2MQTT Light, Media Player | Zigbee2MQTT, deCONZ, ZHA |
| ![Aqara WXKG01LM]() | [WXKG01LM]() | Aqara | Light, Zigbee2MQTT Light | Zigbee2MQTT, deCONZ, ZHA |
| ![Aqara WXKG02LM]() | [WXKG02LM]() | Aqara | Light, Zigbee2MQTT Light, Switch | Zigbee2MQTT, deCONZ, ZHA |
| ![Aqara WXKG06LM]() | [WXKG06LM]() | Aqara | Light, Switch | Zigbee2MQTT, deCONZ |
| ![Aqara WXKG07LM]() | [WXKG07LM]() | Aqara | Light, Zigbee2MQTT Light, Switch | Zigbee2MQTT, deCONZ, ZHA |
| ![Aqara WXKG11LMRemote]() | [WXKG11LMRemote]() | Aqara | Light, Zigbee2MQTT Light | Zigbee2MQTT, deCONZ, ZHA |
| ![Aqara WXKG11LMSensorSwitch]() | [WXKG11LMSensorSwitch]() | Aqara | Light | deCONZ, ZHA |
| ![Aqara WXKG12LM]() | [WXKG12LM]() | Aqara | Light, Zigbee2MQTT Light | Zigbee2MQTT, deCONZ |
| ![Aqara WXKG15LM]() | [WXKG15LM]() | Aqara | Light, Zigbee2MQTT Light, Switch | Zigbee2MQTT |
| ![Lutron Z31BRL]() | [Z31BRL]() | Lutron | Light, Zigbee2MQTT Light | Zigbee2MQTT, deCONZ |
| ![RGB Genie ZB3009]() | [ZB3009](