Editing Openai/691a15e5-9180-8001-a5a0-9b83ec27e6fe (section)

=== Assistant: Sì, è possibile, ma al momento non risulta esistere un binding pubblico/ufficiale per EL.MO e-Connect in openHAB. ===
Sì, è possibile, ma al momento non risulta esistere un binding pubblico/ufficiale per EL.MO e-Connect in openHAB.
L’integrazione che citi è quella di Home Assistant (ha-econnect-alarm) sviluppata in Python e rilasciata con licenza BSD-3, quindi tecnicamente è lecito riusare il codice/protocollo per scrivere un binding Java per openHAB, rispettando i termini di licenza. GitHub<ref>{{cite web|title=GitHub|url=https://github.com/palazzem/ha-econnect-alarm|publisher=github.com|access-date=2025-11-17}}</ref>

Ti rispondo in tre parti:

==== - Esiste una integrazione ufficiale per Home Assistant: ha-econnect-alarm, che parla con il cloud e-Connect / Metronet. GitHub<ref>{{cite web|title=GitHub|url=https://github.com/palazzem/ha-econnect-alarm|publisher=github.com|access-date=2025-11-17}}</ref> ====
* In openHAB ci sono binding per altri allarmi (Satel, Paradox, Jablotron, ecc.) openhab.org<ref>{{cite web|title=openhab.org|url=https://www.openhab.org/addons/bindings/paradoxalarm/|publisher=openhab.org|access-date=2025-11-17}}</ref> ma non per EL.MO/e-Connect.
* Qualcuno ha già chiesto lo sviluppo di un binding “E-connect per openHAB” partendo proprio dal codice Python per Home Assistant (annuncio lavoro freelance), ma non sembra esserci un risultato open-source pubblicato. Freelancer<ref>{{cite web|title=Freelancer|url=https://www.freelancer.de/job-search/openhab/|publisher=freelancer.de|access-date=2025-11-17}}</ref>

Quindi:
👉 non c’è qualcosa “pronto da installare”, ma si può fare.

==== Se l’obiettivo è “far vedere l’allarme ad openHAB” più che sviluppare tu un binding Java, la strada più semplice oggi è: ====
# Installare Home Assistant (anche su un container/VM/raspi dove hai già openHAB).
# Installare l’integrazione Elmo/IESS Alarm (ha-econnect-alarm) tramite HACS / custom component. Home Assistant Community<ref>{{cite web|title=Home Assistant Community|url=https://community.home-assistant.io/t/elmo-alarm/246767|publisher=Home Assistant Community|access-date=2025-11-17}}</ref>
# In HA: - Crei l’entità alarm_control_panel + i sensori (settori, ingressi, ecc.).
# Esportare verso openHAB via MQTT: - In HA attivi l’integrazione MQTT (broker esterno o Mosquitto sullo stesso host). - Esponi lo stato dell’allarme + sensori su topic MQTT (puoi anche usare MQTT Discovery, che openHAB capisce molto bene). openhab.org<ref>{{cite web|title=openhab.org|url=https://www.openhab.org/docs/tutorial/things_advanced.html|publisher=openhab.org|access-date=2025-11-17}}</ref>
# In openHAB: - Usi il binding MQTT. - Crei una Thing MQTT per l’allarme ed i vari sensori, collegando i topic ai Channels. - Da lì in poi usi tutto come se fosse “nativo” in openHAB (items, regole, sitemap, UI, ecc.).

Pro:
* Zero reverse-engineering del protocollo EL.MO.
* Tutto l’“sporco lavoro” con e-Connect lo fa l’integrazione di Home Assistant, che è già funzionante e mantenuta. GitHub<ref>{{cite web|title=GitHub|url=https://github.com/palazzem/ha-econnect-alarm|publisher=github.com|access-date=2025-11-17}}</ref>

Contro:
* Hai un componente in più (Home Assistant) che gira in parallelo ad openHAB.

Se vuoi, in un messaggio successivo posso scriverti esempi di config MQTT + Things/Items basati sulla struttura tipica di ha-econnect-alarm.

==== Se invece vuoi un vero binding openHAB, la strada è: ====

===== - Binding ID: org.openhab.binding.econnect =====
* Bridge Thing: account e-Connect / Metronet Config: - username - password - system (Elmo / IESS) - domain (come nell’integrazione HA: default, vendor, ecc.) GitHub<ref>{{cite web|title=GitHub|url=https://github.com/palazzem/ha-econnect-alarm|publisher=github.com|access-date=2025-11-17}}</ref> - eventuali parametri (polling interval, timeout, ecc.)
* Child Things: - alarm_panel (stato generale, comandi arm/disarm). - area / sector (stato di singole aree/settori). - opzionale: input / output per ingressi/uscite.
* Channels (esempio): - alarm_panel: - arm_state (String/enum: DISARMED, ARMED_AWAY, ARMED_HOME, ARMED_NIGHT…) - command (String o Rollershutter-style, su cui intercetti i comandi in handleCommand) - last_event (String) - sector: - open (Contact) - alarm (Switch) - ecc.

===== Nel repo di HA trovi tutta la logica di accesso al cloud e-Connect in Python: GitHub<ref>{{cite web|title=GitHub|url=https://github.com/palazzem/ha-econnect-alarm|publisher=github.com|access-date=2025-11-17}}</ref> =====
* custom_components/econnect_metronet/ lì ci sono: - il client che fa login (POST iniziale), gestisce i cookie/sessione, recupera lo stato. - le chiamate per armare/disarmare e leggere i settori.

Passi pratici:
# Studiare il client Python - Chiamate HTTP (endpoint, metodo, payload, headers). - Meccanismo di login (form, JSON, token). - Formato del JSON restituito con lo stato (zone, inputs, outputs, ecc.).
# Riscrivere il client in Java dentro il binding: - usare Apache HttpClient o la HTTP API di openHAB (a seconda della versione) per le chiamate. - mappare le risposte JSON con Jackson / GSON.
# Schedulare il polling: - Nel BridgeHandler.initialize() avviare uno scheduler (scheduler.scheduleWithFixedDelay) che ogni X secondi: - aggiorna lo stato dal cloud - chiama updateState(...) sui Channels delle Things figlie.
# Gestire i comandi: - Nel ThingHandler.handleCommand(...) dell’alarm panel, tradurre ON/OFF o comandi stringa in chiamate HTTP (arm/disarm). - Inserire la necessaria sicurezza: p.e. un String channel per il codice PIN, o usare un Item separato.

===== : =====

<code>EconnectBindingConstants.java</code>

<syntaxhighlight lang="java">package org.openhab.binding.econnect;

public class EconnectBindingConstants {

    public static final String BINDING_ID = "econnect";

    // Thing types
    public static final String THING_TYPE_BRIDGE = "bridge";
    public static final String THING_TYPE_ALARM_PANEL = "alarm_panel";

    // Channels - alarm panel
    public static final String CHANNEL_ALARM_STATE = "alarm_state";
    public static final String CHANNEL_LAST_EVENT = "last_event";
    public static final String CHANNEL_COMMAND = "command";
}

</syntaxhighlight>

<code>EconnectHandlerFactory.java</code>

<syntaxhighlight lang="java">package org.openhab.binding.econnect.internal;

import static org.openhab.binding.econnect.EconnectBindingConstants.*;

import java.util.Set;

import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.ThingTypeUID;
import org.openhab.core.thing.binding.BaseThingHandlerFactory;
import org.openhab.core.thing.binding.ThingHandler;
import org.openhab.core.thing.binding.BridgeHandler;
import org.osgi.service.component.annotations.Component;

@NonNullByDefault
@Component(service = org.openhab.core.thing.binding.ThingHandlerFactory.class)
public class EconnectHandlerFactory extends BaseThingHandlerFactory {

    public static final ThingTypeUID BRIDGE_TYPE_UID = new ThingTypeUID(BINDING_ID, THING_TYPE_BRIDGE);
    public static final ThingTypeUID ALARM_PANEL_TYPE_UID = new ThingTypeUID(BINDING_ID, THING_TYPE_ALARM_PANEL);

    @Override
    public boolean supportsThingType(ThingTypeUID thingTypeUID) {
        return BRIDGE_TYPE_UID.equals(thingTypeUID) || ALARM_PANEL_TYPE_UID.equals(thingTypeUID);
    }

    @Override
    protected @Nullable ThingHandler createHandler(Thing thing) {
        ThingTypeUID thingTypeUID = thing.getThingTypeUID();

        if (BRIDGE_TYPE_UID.equals(thingTypeUID)) {
            return new EconnectBridgeHandler(thing);
        } else if (ALARM_PANEL_TYPE_UID.equals(thingTypeUID)) {
            return new EconnectAlarmPanelHandler(thing);
        }
        return null;
    }
}

</syntaxhighlight>

<code>EconnectBridgeHandler.java</code>

<syntaxhighlight lang="java">package org.openhab.binding.econnect.internal;

import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.core.thing.Bridge;
import org.openhab.core.thing.ThingStatus;
import org.openhab.core.thing.ThingStatusDetail;
import org.openhab.core.thing.binding.BaseBridgeHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@NonNullByDefault
public class EconnectBridgeHandler extends BaseBridgeHandler {

    private final Logger logger = LoggerFactory.getLogger(EconnectBridgeHandler.class);

    private ScheduledFuture<?> refreshJob;

    // Qui andrebbe il tuo client Java per e-Connect
    private EconnectClient client;

    public EconnectBridgeHandler(Bridge bridge) {
        super(bridge);
    }

    @Override
    public void initialize() {
        logger.debug("Initializing Econnect bridge");

        // TODO: leggere i parametri di config (username, password, system, domain, pollInterval)
        // Eseguire login sul cloud
        try {
            // client = new EconnectClient(config...);
            // client.login();

            updateStatus(ThingStatus.ONLINE);

            int pollIntervalSeconds = 10; // o da config
            refreshJob = scheduler.scheduleWithFixedDelay(this::refresh, 0, pollIntervalSeconds, TimeUnit.SECONDS);
        } catch (Exception e) {
            updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, e.getMessage());
        }
    }

    private void refresh() {
        try {
            // Legge stato dal cloud
            // EconnectState state = client.getState();

            // Propagare lo stato alle Things figlie
            getThing().getThings().forEach(child -> {
                if (child.getHandler() instanceof EconnectAlarmPanelHandler panelHandler) {
                    // panelHandler.updateFromState(state);
                }
            });
        } catch (Exception e) {
            logger.warn("Error refreshing Econnect state", e);
        }
    }

    @Override
    public void dispose() {
        if (refreshJob != null && !refreshJob.isCancelled()) {
            refreshJob.cancel(true);
        }
        // client.logout() se necessario
        super.dispose();
    }

    public EconnectClient getClient() {
        return client;
    }
}

</syntaxhighlight>

<code>EconnectAlarmPanelHandler.java</code>

<syntaxhighlight lang="java">package org.openhab.binding.econnect.internal;

import static org.openhab.binding.econnect.EconnectBindingConstants.*;

import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.core.library.types.StringType;
import org.openhab.core.library.types.OnOffType;
import org.openhab.core.thing.ChannelUID;
import org.openhab.core.thing.Thing;
import org.openhab.core.thing.binding.BaseThingHandler;
import org.openhab.core.types.Command;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@NonNullByDefault
public class EconnectAlarmPanelHandler extends BaseThingHandler {

    private final Logger logger = LoggerFactory.getLogger(EconnectAlarmPanelHandler.class);

    public EconnectAlarmPanelHandler(Thing thing) {
        super(thing);
    }

    @Override
    public void initialize() {
        updateStatus(org.openhab.core.thing.ThingStatus.UNKNOWN);
    }

    @Override
    public void handleCommand(ChannelUID channelUID, Command command) {
        if (CHANNEL_COMMAND.equals(channelUID.getId())) {
            logger.debug("Received command {} for alarm panel", command);

            if (command instanceof OnOffType) {
                // esempio: ON = arm_away, OFF = disarm
                String action = command == OnOffType.ON ? "arm_away" : "disarm";
                sendAlarmCommand(action);
            } else if (command instanceof StringType stringCmd) {
                sendAlarmCommand(stringCmd.toString()); // "arm_home", "arm_night", etc.
            }
        }
    }

    private void sendAlarmCommand(String action) {
        try {
            EconnectBridgeHandler bridge = (EconnectBridgeHandler) getBridge().getHandler();
            EconnectClient client = bridge.getClient();

            switch (action) {
                case "arm_away":
                    client.armAllAreas();
                    break;
                case "disarm":
                    client.disarmAllAreas();
                    break;
                case "arm_home":
                    client.armHome();
                    break;
                case "arm_night":
                    client.armNight();
                    break;
                default:
                    logger.warn("Unknown alarm action: {}", action);
            }
        } catch (Exception e) {
            logger.warn("Failed to send alarm command {}", action, e);
        }
    }

    // Chiamata dal Bridge quando ha un nuovo stato
    public void updateFromState(EconnectState state) {
        // TODO: mappare lo stato generale dell’allarme
        // updateState(new ChannelUID(getThing().getUID(), CHANNEL_ALARM_STATE),
        //            new StringType(state.getAlarmStatus()));
    }
}

</syntaxhighlight>

===== - Implementare <code>EconnectClient</code> (login, polling, comandi) copiando la logica del client Python. =====
* Definire i file XML: - econnect.things (thing-types, channels, ecc.). - econnect.config (parametri di configurazione del bridge).
* Integrare il binding nel repository openHAB (o come add-on esterno in addons/).
* Fare un po’ di test con il tuo impianto reale.

==== - Sì, è possibile integrare EL.MO e-Connect in openHAB, ma non esiste un binding pronto. ====
* Il porting della integrazione di Home Assistant è realistico, ma significa riscriverla in Java come binding openHAB.
* Nel frattempo, la soluzione più pratica è: - e-Connect → Home Assistant (ha-econnect-alarm) → MQTT → openHAB.

Se mi dici “preferisco la strada HA → MQTT” oppure “voglio provare a scrivere il binding”, nel prossimo messaggio ti preparo:
* o uno schema completo di Topics MQTT + Things/Items openHAB
* oppure i passi di build del progetto Maven del binding + struttura dei file XML.