ENKI in home assistant

[xSzczurekk]

I have a bluetooth ceiling lamp from Leroy Merlin. they can be controlled by their ENKI application, I would like to add it to the home assistant somehow, but I have a very big problem because I don’t know how to do it. If someone has already done it or also has the same problem, write everything here.

[davidepolizzi]

Same here Inspire Gdansk ENKI

[faberman]

Bought some ENKI lights at a sale as well. Very disappointed about the app and the requirements to register to some cloud service. Did some BT HCI sniffing and identified the chip, the lamps use die BT mesh from Silicon Laboratories. In the “Simplicity Connect” app the lights show up and can be controlled, so it should not be hard to integrate them.

[CyrilP]

I wrote a small integration for enki app (cloud mode) to support my Eglo v-link tunable white, you can give it a try : GitHub - CyrilP/hass-enki-component: Enki custom component for Home Assistant
maybe it will also work for your lamp

[nicok (Nicolas Kadi)]

Hello,
I try to your integration in HA. I see also one entry : my address mail. But nothing of my modules evology for a roller shutter. Could you help me, please.

[CyrilP]

Only lights are supported as this is the only thing I have.
I need an access to an account with more modules to implement them

[nicok (Nicolas Kadi)]

Hello,
I prefere to give a church witch CHATPGP and this information. If you can read the result and possible to adapt your code of API. That very kind.
Thanks

Objectif :
Ajouter la prise en charge des modules Evology (Leroy Merlin) en protocole EnOcean pour piloter des volets roulants via l’API Enki.

---

Compréhension de l’existant (hass-enki-component)

Tu as déjà la structure suivante :

custom_components/enki/
│── __init__.py
│── api.py
│── base.py
│── config_flow.py
│── const.py
│── coordinator.py
│── light.py
│── manifest.json
│── __pycache__/

Actuellement :

• light.py gère les lumières
• pas encore de cover.py
• l’API Enki est déjà abstraite dans api.py
• base.py sert de classe commune aux entités
• coordinator.py gère le refresh des données

---

Ce qu’on va ajouter

1. Support du type d’appareil

• MODULES_EVLOGY
• protocole ENOCEAN
• catégorie Home Assistant → cover

2. Nouveau fichier cover.py
3. Détection du device Enki (type volet)
4. Commandes :

• ouvrir
• fermer
• stop
• (optionnel) position %

---

Étape 1 – Identifier les volets Evology côté API Enki

Dans les retours API Enki (api.py), tu dois avoir des devices du genre :

{
  "id": "xxxx",
  "deviceType": "ROLLER_SHUTTER",
  "brand": "EVOLOGY",
  "protocol": "ENOCEAN",
  "capabilities": ["OPEN", "CLOSE", "STOP"]
}

Les champs importants :

• deviceType
• protocol
• capabilities

On va se baser là-dessus.

---

Étape 2 – Ajouter les constantes

const.py

DOMAIN = "enki"

DEVICE_TYPE_LIGHT = "LIGHT"
DEVICE_TYPE_ROLLER_SHUTTER = "ROLLER_SHUTTER"

PROTOCOL_ENOCEAN = "ENOCEAN"

PLATFORMS = ["light", "cover"]

Assure-toi que cover est bien ajouté à PLATFORMS.

---

Étape 3 – Créer cover.py

custom_components/enki/cover.py

from homeassistant.components.cover import (
    CoverEntity,
    CoverEntityFeature,
)
from homeassistant.const import STATE_OPEN, STATE_CLOSED

from .base import EnkiBaseEntity
from .const import DEVICE_TYPE_ROLLER_SHUTTER


class EnkiCover(EnkiBaseEntity, CoverEntity):
    """Représentation d'un volet roulant Enki (Evology / EnOcean)."""

    _attr_supported_features = (
        CoverEntityFeature.OPEN
        | CoverEntityFeature.CLOSE
        | CoverEntityFeature.STOP
    )

    def __init__(self, coordinator, device):
        super().__init__(coordinator, device)
        self._attr_name = device.get("name")

    @property
    def is_closed(self):
        state = self.device.get("state")
        return state == "CLOSED"

    async def async_open_cover(self, **kwargs):
        await self.coordinator.api.set_device_state(
            self.device["id"], "OPEN"
        )

    async def async_close_cover(self, **kwargs):
        await self.coordinator.api.set_device_state(
            self.device["id"], "CLOSE"
        )

    async def async_stop_cover(self, **kwargs):
        await self.coordinator.api.set_device_state(
            self.device["id"], "STOP")

---

Étape 4 – Étendre l’API Enki

api.py

Ajoute (ou adapte) une méthode générique :

async def set_device_state(self, device_id: str, action: str):
    url = f"{self._base_url}/api/user/{self._user_id}/device/{device_id}"
    payload = {"action": action}

    await self._session.put(
        url,
        headers=self._headers,
        json=payload,
    )

Enki utilise souvent action plutôt que state pour les volets.

---

Étape 5 – Déclarer la plateforme cover

__init__.py

Vérifie que les plateformes sont bien forwardées :

await hass.config_entries.async_forward_entry_setups(
    entry, ["light", "cover"]
)

---

Étape 6 – Détection des volets dans coordinator.py

Dans la création des entités :

from .cover import EnkiCover
from .const import DEVICE_TYPE_ROLLER_SHUTTER

entities = []

for device in devices:
    if device["deviceType"] == DEVICE_TYPE_ROLLER_SHUTTER:
        entities.append(EnkiCover(coordinator, device))

---

Étape 7 – Manifest

manifest.json

Vérifie :

{
  "domain": "enki",
  "name": "Enki",
  "version": "0.2.0",
  "platforms": ["light", "cover"],
  "iot_class": "cloud_polling"
}

---

Limitations EnOcean / Evology

Très important :

• EnOcean ne remonte souvent pas l’état réel
• is_closed peut être optimiste
• Pas toujours de position %
• STOP parfois non supporté selon le module

Home Assistant affichera donc un état estimé.

---

Améliorations possibles

• Ajout set_cover_position
• Mapping dynamique des capabilities
• Gestion des erreurs API
• Fallback si STOP non supporté
• Debug logger spécifique aux devices EnOcean

---

Prochaine étape (je te propose)

Si tu veux, au prochain message :

1. Tu me colles un exemple JSON réel d’un volet Evology depuis l’API Enki
2. Ou le contenu actuel de api.py / base.py

Je t’adapterai le code exactement à TON API Enki, sans suppositions.

et les modules ont un état de position

Parfait
Si les modules Evology EnOcean remontent une position, alors on peut faire une intégration “propre” Home Assistant avec position %, ce qui est excellent pour les volets.

Je vais t’expliquer quoi modifier exactement dans le composant existant pour :

• gérer current_position
• supporter set_cover_position
• garder OPEN / CLOSE / STOP
• rester compatible Enki / EnOcean

---

Hypothèse réaliste côté API Enki

Un volet Evology EnOcean expose généralement quelque chose comme :

{
  "id": "abcd1234",
  "name": "Volet Salon",
  "deviceType": "ROLLER_SHUTTER",
  "protocol": "ENOCEAN",
  "state": "OPEN",
  "position": 42,
  "capabilities": [
    "OPEN",
    "CLOSE",
    "STOP",
    "SET_POSITION"
  ]
}

• position → confirmée (0–100)
• SET_POSITION → clé pour HA

---

Étape 1 – Mettre à jour les constantes

const.py

DEVICE_TYPE_ROLLER_SHUTTER = "ROLLER_SHUTTER"

CAPABILITY_SET_POSITION = "SET_POSITION"

---

Étape 2 – API : commande de position

api.py

Ajoute une méthode dédiée (plus clair que surcharger set_device_state) :

async def set_cover_position(self, device_id: str, position: int):
    url = f"{self._base_url}/api/user/{self._user_id}/device/{device_id}"
    payload = {
        "action": "SET_POSITION",
        "position": position
    }

    await self._session.put(
        url,
        headers=self._headers,
        json=payload,
    )

Enki demande presque toujours action + position, même si position est seul logique.

---

Étape 3 – CoverEntity avec position %

cover.py

from homeassistant.components.cover import (
    CoverEntity,
    CoverEntityFeature,
)

from .base import EnkiBaseEntity
from .const import CAPABILITY_SET_POSITION


class EnkiCover(EnkiBaseEntity, CoverEntity):
    """Volet roulant Enki Evology (EnOcean)."""

    def __init__(self, coordinator, device):
        super().__init__(coordinator, device)
        self._attr_name = device.get("name")

        self._attr_supported_features = (
            CoverEntityFeature.OPEN
            | CoverEntityFeature.CLOSE
            | CoverEntityFeature.STOP
        )

        if CAPABILITY_SET_POSITION in device.get("capabilities", []):
            self._attr_supported_features |= CoverEntityFeature.SET_POSITION

    @property
    def current_cover_position(self):
        return self.device.get("position")

    @property
    def is_closed(self):
        pos = self.current_cover_position
        return pos == 0 if pos is not None else None

    async def async_open_cover(self, **kwargs):
        await self.coordinator.api.set_device_state(
            self.device["id"], "OPEN"
        )

    async def async_close_cover(self, **kwargs):
        await self.coordinator.api.set_device_state(
            self.device["id"], "CLOSE"
        )

    async def async_stop_cover(self, **kwargs):
        await self.coordinator.api.set_device_state(
            self.device["id"], "STOP"
        )

    async def async_set_cover_position(self, **kwargs):
        position = kwargs.get("position")
        await self.coordinator.api.set_cover_position(
            self.device["id"], position
        )

---

Étape 4 – Coordinator : rafraîchissement position

coordinator.py

Vérifie que les données sont bien rafraîchies après commande :

await self.async_request_refresh()

Sinon la position HA ne se mettra pas à jour après un mouvement.

---

Étape 5 – Résultat dans Home Assistant

Tu obtiens :

Curseur de position
Boutons ouvrir / fermer / stop
Compatible automatisations
Compatible scènes
Compatible dashboard Lovelace

---

Points critiques EnOcean (retour terrain)

Point	Comportement
Précision	±5% parfois
STOP	Pas toujours instantané
Position	Peut être mise à jour avec délai
État réel	Dépend du module Evology

Mais Home Assistant gère très bien ça.

---

Amélioration avancée (optionnelle)

Si tu veux un truc ultra propre :

• assumed_state = False
• Historique des positions
• Détection de mouvement (opening / closing)
• Gestion optimistic fallback si position absente

---

Prochaine étape (je te propose)

Pour être 100% exact :
colle-moi un vrai JSON d’un volet Evology depuis l’API Enki
(ou le mapping exact state / position / capabilities)

Je t’adapterai le code au champ près, prêt à commit

[CyrilP]

try these changes with your HA and propose a merge request

[nicok (Nicolas Kadi)]

I don’t know to adapt your code and I’m not confortable with that. And You, it’s not possible to change your code with an information go ChatGPT and then I could test ?