homebridge-evn-smartmeter 1.0.0

package/dist/accessories/voltageMonitorAccessory.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoltageMonitorAccessory = void 0;
+const topicParser_1 = require("../mqtt/topicParser");
+const types_1 = require("../config/types");
+/**
+ * Voltage Monitor Accessory
+ * Displays voltage measurements as temperature sensors (°C = Volt)
+ */
+class VoltageMonitorAccessory {
+    constructor(platform, accessory, mqttClient) {
+        this.platform = platform;
+        this.accessory = accessory;
+        this.mqttClient = mqttClient;
+        this.services = [];
+        this.cachedValues = new Map();
+        // Set accessory information
+        this.accessory
+            .getService(this.platform.Service.AccessoryInformation)
+            .setCharacteristic(this.platform.Characteristic.Manufacturer, 'EVN')
+            .setCharacteristic(this.platform.Characteristic.Model, 'Kaifa Smartmeter - Voltage Monitor')
+            .setCharacteristic(this.platform.Characteristic.SerialNumber, 'VOL-001');
+        // Create temperature sensors for voltage measurements
+        this.createSensor('Voltage L1 (V)', types_1.MeasurementType.SpannungL1);
+        this.createSensor('Voltage L2 (V)', types_1.MeasurementType.SpannungL2);
+        this.createSensor('Voltage L3 (V)', types_1.MeasurementType.SpannungL3);
+        // Subscribe to MQTT measurements
+        this.mqttClient.on('measurement', this.handleMeasurement.bind(this));
+    }
+    /**
+     * Create a temperature sensor for a voltage measurement
+     */
+    createSensor(name, type) {
+        const service = this.accessory.getService(name) ||
+            this.accessory.addService(this.platform.Service.TemperatureSensor, name, type);
+        service
+            .getCharacteristic(this.platform.Characteristic.CurrentTemperature)
+            .setProps({
+            minValue: 0,
+            maxValue: 300,
+            minStep: 0.1,
+        })
+            .onGet(() => this.getValue(type));
+        this.services.push(service);
+    }
+    /**
+     * Get the current value for a measurement type
+     */
+    getValue(type) {
+        return this.cachedValues.get(type) ?? 0;
+    }
+    /**
+     * Handle incoming MQTT measurement
+     */
+    handleMeasurement(topic, value) {
+        const measurementType = (0, topicParser_1.parseTopic)(topic, this.platform.config.mqtt.topic_prefix || 'Smartmeter');
+        if (!measurementType) {
+            return;
+        }
+        // Check if this measurement belongs to this accessory
+        if (measurementType !== types_1.MeasurementType.SpannungL1 &&
+            measurementType !== types_1.MeasurementType.SpannungL2 &&
+            measurementType !== types_1.MeasurementType.SpannungL3) {
+            return;
+        }
+        // Update cache
+        this.cachedValues.set(measurementType, value);
+        // Update HomeKit characteristic
+        const service = this.services.find((s) => s.subtype === measurementType);
+        if (service) {
+            service.getCharacteristic(this.platform.Characteristic.CurrentTemperature).updateValue(value);
+        }
+    }
+}
+exports.VoltageMonitorAccessory = VoltageMonitorAccessory;

package/dist/config/defaults.d.ts

@@ -0,0 +1,4 @@
+import { DisplayConfig } from './types';
+export declare const DEFAULT_MQTT_PORT = 1883;
+export declare const DEFAULT_TOPIC_PREFIX = "Smartmeter";
+export declare const DEFAULT_DISPLAY_CONFIG: DisplayConfig;

package/dist/config/defaults.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DISPLAY_CONFIG = exports.DEFAULT_TOPIC_PREFIX = exports.DEFAULT_MQTT_PORT = void 0;
+exports.DEFAULT_MQTT_PORT = 1883;
+exports.DEFAULT_TOPIC_PREFIX = 'Smartmeter';
+exports.DEFAULT_DISPLAY_CONFIG = {
+    showPowerMonitor: true,
+    showEnergyMeter: true,
+    showVoltageMonitor: true,
+    showCurrentMonitor: true,
+};

package/dist/config/types.d.ts

@@ -0,0 +1,33 @@
+export interface EVNSmartmeterConfig {
+    platform: string;
+    name?: string;
+    mqtt: MQTTConfig;
+    display?: DisplayConfig;
+}
+export interface MQTTConfig {
+    broker: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    topic_prefix?: string;
+}
+export interface DisplayConfig {
+    showPowerMonitor?: boolean;
+    showEnergyMeter?: boolean;
+    showVoltageMonitor?: boolean;
+    showCurrentMonitor?: boolean;
+}
+export declare enum MeasurementType {
+    WirkenergieP = "WirkenergieP",
+    WirkenergieN = "WirkenergieN",
+    MomentanleistungP = "MomentanleistungP",
+    MomentanleistungN = "MomentanleistungN",
+    Momentanleistung = "Momentanleistung",
+    SpannungL1 = "SpannungL1",
+    SpannungL2 = "SpannungL2",
+    SpannungL3 = "SpannungL3",
+    StromL1 = "StromL1",
+    StromL2 = "StromL2",
+    StromL3 = "StromL3",
+    Leistungsfaktor = "Leistungsfaktor"
+}

package/dist/config/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeasurementType = void 0;
+var MeasurementType;
+(function (MeasurementType) {
+    MeasurementType["WirkenergieP"] = "WirkenergieP";
+    MeasurementType["WirkenergieN"] = "WirkenergieN";
+    MeasurementType["MomentanleistungP"] = "MomentanleistungP";
+    MeasurementType["MomentanleistungN"] = "MomentanleistungN";
+    MeasurementType["Momentanleistung"] = "Momentanleistung";
+    MeasurementType["SpannungL1"] = "SpannungL1";
+    MeasurementType["SpannungL2"] = "SpannungL2";
+    MeasurementType["SpannungL3"] = "SpannungL3";
+    MeasurementType["StromL1"] = "StromL1";
+    MeasurementType["StromL2"] = "StromL2";
+    MeasurementType["StromL3"] = "StromL3";
+    MeasurementType["Leistungsfaktor"] = "Leistungsfaktor";
+})(MeasurementType || (exports.MeasurementType = MeasurementType = {}));

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { API } from 'homebridge';
+/**
+ * This method registers the platform with Homebridge
+ */
+declare const _default: (api: API) => void;
+export = _default;

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+const settings_1 = require("./settings");
+const platform_1 = require("./platform");
+module.exports = (api) => {
+    api.registerPlatform(settings_1.PLATFORM_NAME, platform_1.EVNSmartmeterPlatform);
+};

package/dist/mqtt/mqttClient.d.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from 'events';
+/**
+ * MQTT client manager with auto-reconnect
+ * Emits events:
+ * - 'connected': When successfully connected to broker
+ * - 'measurement': (topic: string, value: number) - When a valid measurement is received
+ * - 'error': (error: Error) - On MQTT errors
+ * - 'offline': When connection is lost
+ */
+export declare class EVNMQTTClient extends EventEmitter {
+    private broker;
+    private port;
+    private topicPrefix;
+    private username?;
+    private password?;
+    private client;
+    private reconnectAttempts;
+    private isConnected;
+    constructor(broker: string, port: number, topicPrefix: string, username?: string | undefined, password?: string | undefined);
+    /**
+     * Connect to MQTT broker
+     */
+    connect(): void;
+    /**
+     * Disconnect from MQTT broker
+     */
+    disconnect(): void;
+    /**
+     * Handle successful connection
+     */
+    private handleConnect;
+    /**
+     * Handle incoming MQTT message
+     */
+    private handleMessage;
+    /**
+     * Handle MQTT errors
+     */
+    private handleError;
+    /**
+     * Handle offline event
+     */
+    private handleOffline;
+    /**
+     * Handle reconnection attempt
+     */
+    private handleReconnect;
+    /**
+     * Get connection status
+     */
+    getConnectionStatus(): boolean;
+    /**
+     * Get reconnect attempts count
+     */
+    getReconnectAttempts(): number;
+}

package/dist/mqtt/mqttClient.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVNMQTTClient = void 0;
+const mqtt_1 = __importDefault(require("mqtt"));
+const events_1 = require("events");
+/**
+ * MQTT client manager with auto-reconnect
+ * Emits events:
+ * - 'connected': When successfully connected to broker
+ * - 'measurement': (topic: string, value: number) - When a valid measurement is received
+ * - 'error': (error: Error) - On MQTT errors
+ * - 'offline': When connection is lost
+ */
+class EVNMQTTClient extends events_1.EventEmitter {
+    constructor(broker, port, topicPrefix, username, password) {
+        super();
+        this.broker = broker;
+        this.port = port;
+        this.topicPrefix = topicPrefix;
+        this.username = username;
+        this.password = password;
+        this.client = null;
+        this.reconnectAttempts = 0;
+        this.isConnected = false;
+    }
+    /**
+     * Connect to MQTT broker
+     */
+    connect() {
+        const options = {
+            host: this.broker,
+            port: this.port,
+            username: this.username,
+            password: this.password,
+            reconnectPeriod: 1000, // Start reconnect attempts after 1 second
+            connectTimeout: 10000, // 10 second connection timeout
+        };
+        this.client = mqtt_1.default.connect(options);
+        this.client.on('connect', () => this.handleConnect());
+        this.client.on('message', (topic, message) => this.handleMessage(topic, message));
+        this.client.on('error', (error) => this.handleError(error));
+        this.client.on('offline', () => this.handleOffline());
+        this.client.on('reconnect', () => this.handleReconnect());
+    }
+    /**
+     * Disconnect from MQTT broker
+     */
+    disconnect() {
+        if (this.client) {
+            this.client.end();
+            this.client = null;
+            this.isConnected = false;
+        }
+    }
+    /**
+     * Handle successful connection
+     */
+    handleConnect() {
+        this.reconnectAttempts = 0;
+        this.isConnected = true;
+        // Subscribe to all topics under the prefix
+        const subscriptionTopic = `${this.topicPrefix}/#`;
+        this.client?.subscribe(subscriptionTopic, { qos: 0 }, (err) => {
+            if (err) {
+                this.emit('error', new Error(`Failed to subscribe to ${subscriptionTopic}: ${err.message}`));
+            }
+            else {
+                this.emit('connected');
+            }
+        });
+    }
+    /**
+     * Handle incoming MQTT message
+     */
+    handleMessage(topic, message) {
+        try {
+            const valueStr = message.toString().trim();
+            const value = parseFloat(valueStr);
+            if (isNaN(value)) {
+                // Invalid value - log but don't crash
+                this.emit('error', new Error(`Invalid MQTT value for ${topic}: "${valueStr}"`));
+                return;
+            }
+            // Emit measurement event
+            this.emit('measurement', topic, value);
+        }
+        catch (error) {
+            this.emit('error', new Error(`Error processing MQTT message for ${topic}: ${error}`));
+        }
+    }
+    /**
+     * Handle MQTT errors
+     */
+    handleError(error) {
+        this.emit('error', error);
+    }
+    /**
+     * Handle offline event
+     */
+    handleOffline() {
+        this.isConnected = false;
+        this.emit('offline');
+    }
+    /**
+     * Handle reconnection attempt
+     */
+    handleReconnect() {
+        this.reconnectAttempts++;
+    }
+    /**
+     * Get connection status
+     */
+    getConnectionStatus() {
+        return this.isConnected;
+    }
+    /**
+     * Get reconnect attempts count
+     */
+    getReconnectAttempts() {
+        return this.reconnectAttempts;
+    }
+}
+exports.EVNMQTTClient = EVNMQTTClient;

package/dist/mqtt/topicParser.d.ts

@@ -0,0 +1,8 @@
+import { MeasurementType } from '../config/types';
+/**
+ * Parse an MQTT topic and extract the measurement type
+ * @param fullTopic - The full MQTT topic (e.g., "Smartmeter/Momentanleistung")
+ * @param topicPrefix - The configured topic prefix (e.g., "Smartmeter")
+ * @returns The measurement type or null if the topic doesn't match
+ */
+export declare function parseTopic(fullTopic: string, topicPrefix: string): MeasurementType | null;

package/dist/mqtt/topicParser.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTopic = parseTopic;
+const types_1 = require("../config/types");
+/**
+ * Parse an MQTT topic and extract the measurement type
+ * @param fullTopic - The full MQTT topic (e.g., "Smartmeter/Momentanleistung")
+ * @param topicPrefix - The configured topic prefix (e.g., "Smartmeter")
+ * @returns The measurement type or null if the topic doesn't match
+ */
+function parseTopic(fullTopic, topicPrefix) {
+    // Normalize prefix - ensure it ends with /
+    const prefix = topicPrefix.endsWith('/') ? topicPrefix : `${topicPrefix}/`;
+    // Check if topic starts with the prefix
+    if (!fullTopic.startsWith(prefix)) {
+        return null;
+    }
+    // Extract measurement name
+    const measurementName = fullTopic.substring(prefix.length);
+    // Check if it's a valid MeasurementType
+    if (Object.values(types_1.MeasurementType).includes(measurementName)) {
+        return measurementName;
+    }
+    return null;
+}

package/dist/platform.d.ts

@@ -0,0 +1,42 @@
+import { API, DynamicPlatformPlugin, Logger, PlatformAccessory, Service, Characteristic } from 'homebridge';
+import { EVNSmartmeterConfig } from './config/types';
+/**
+ * HomebridgePlatform
+ * This class is the main constructor for your plugin, this is where you should
+ * parse the user config and discover/register accessories with Homebridge.
+ */
+export declare class EVNSmartmeterPlatform implements DynamicPlatformPlugin {
+    readonly log: Logger;
+    readonly config: EVNSmartmeterConfig;
+    readonly api: API;
+    readonly Service: typeof Service;
+    readonly Characteristic: typeof Characteristic;
+    readonly accessories: PlatformAccessory[];
+    private mqttClient?;
+    constructor(log: Logger, config: EVNSmartmeterConfig, api: API);
+    /**
+     * This function is invoked when homebridge restores cached accessories from disk at startup.
+     * It should be used to setup event handlers for characteristics and update respective values.
+     */
+    configureAccessory(accessory: PlatformAccessory): void;
+    /**
+     * Initialize the platform and register accessories
+     */
+    private initializePlatform;
+    /**
+     * Discover and register accessories based on configuration
+     */
+    private discoverAccessories;
+    /**
+     * Register an accessory with Homebridge
+     */
+    private registerAccessory;
+    /**
+     * Remove accessories that are disabled in the configuration
+     */
+    private removeDisabledAccessories;
+    /**
+     * Cleanup resources on shutdown
+     */
+    private cleanup;
+}

package/dist/platform.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVNSmartmeterPlatform = void 0;
+const defaults_1 = require("./config/defaults");
+const settings_1 = require("./settings");
+const mqttClient_1 = require("./mqtt/mqttClient");
+const powerMonitorAccessory_1 = require("./accessories/powerMonitorAccessory");
+const energyMeterAccessory_1 = require("./accessories/energyMeterAccessory");
+const voltageMonitorAccessory_1 = require("./accessories/voltageMonitorAccessory");
+const currentMonitorAccessory_1 = require("./accessories/currentMonitorAccessory");
+/**
+ * HomebridgePlatform
+ * This class is the main constructor for your plugin, this is where you should
+ * parse the user config and discover/register accessories with Homebridge.
+ */
+class EVNSmartmeterPlatform {
+    constructor(log, config, api) {
+        this.log = log;
+        this.config = config;
+        this.api = api;
+        this.Service = this.api.hap.Service;
+        this.Characteristic = this.api.hap.Characteristic;
+        // Cached accessories
+        this.accessories = [];
+        // Validate configuration
+        if (!this.config.mqtt?.broker) {
+            this.log.error('MQTT broker not configured! Please configure mqtt.broker in config.json');
+            return;
+        }
+        this.log.info('EVN Smartmeter platform loaded');
+        // When this event is fired it means Homebridge has restored all cached accessories from disk.
+        // Dynamic Platform plugins should only register new accessories after this event was fired,
+        // in order to ensure they weren't added to homebridge already. This event can also be used
+        // to start discovery of new accessories.
+        this.api.on('didFinishLaunching', () => {
+            this.log.info('Finished launching, initializing platform');
+            this.initializePlatform();
+        });
+        // Clean up on shutdown
+        this.api.on('shutdown', () => {
+            this.cleanup();
+        });
+    }
+    /**
+     * This function is invoked when homebridge restores cached accessories from disk at startup.
+     * It should be used to setup event handlers for characteristics and update respective values.
+     */
+    configureAccessory(accessory) {
+        this.log.info('Loading accessory from cache:', accessory.displayName);
+        this.accessories.push(accessory);
+    }
+    /**
+     * Initialize the platform and register accessories
+     */
+    initializePlatform() {
+        // Initialize MQTT client
+        const mqttConfig = this.config.mqtt;
+        this.mqttClient = new mqttClient_1.EVNMQTTClient(mqttConfig.broker, mqttConfig.port || defaults_1.DEFAULT_MQTT_PORT, mqttConfig.topic_prefix || defaults_1.DEFAULT_TOPIC_PREFIX, mqttConfig.username, mqttConfig.password);
+        // Set up MQTT event handlers
+        this.mqttClient.on('connected', () => {
+            this.log.info('MQTT connected successfully');
+        });
+        this.mqttClient.on('error', (error) => {
+            this.log.error('MQTT Error:', error.message);
+        });
+        this.mqttClient.on('offline', () => {
+            this.log.warn('MQTT offline, will attempt to reconnect...');
+        });
+        // Register accessories
+        this.discoverAccessories();
+        // Connect to MQTT broker
+        this.log.info(`Connecting to MQTT broker at ${mqttConfig.broker}:${mqttConfig.port || defaults_1.DEFAULT_MQTT_PORT}`);
+        this.mqttClient.connect();
+    }
+    /**
+     * Discover and register accessories based on configuration
+     */
+    discoverAccessories() {
+        const displayConfig = { ...defaults_1.DEFAULT_DISPLAY_CONFIG, ...this.config.display };
+        if (displayConfig.showPowerMonitor) {
+            this.registerAccessory('Power Monitor', powerMonitorAccessory_1.PowerMonitorAccessory);
+        }
+        if (displayConfig.showEnergyMeter) {
+            this.registerAccessory('Energy Meter', energyMeterAccessory_1.EnergyMeterAccessory);
+        }
+        if (displayConfig.showVoltageMonitor) {
+            this.registerAccessory('Voltage Monitor', voltageMonitorAccessory_1.VoltageMonitorAccessory);
+        }
+        if (displayConfig.showCurrentMonitor) {
+            this.registerAccessory('Current Monitor', currentMonitorAccessory_1.CurrentMonitorAccessory);
+        }
+        // Remove accessories that are no longer enabled
+        this.removeDisabledAccessories(displayConfig);
+    }
+    /**
+     * Register an accessory with Homebridge
+     */
+    registerAccessory(name, AccessoryClass) {
+        const uuid = this.api.hap.uuid.generate(name);
+        const existingAccessory = this.accessories.find((acc) => acc.UUID === uuid);
+        if (existingAccessory) {
+            // Accessory already exists, restore it
+            this.log.info('Restoring existing accessory from cache:', existingAccessory.displayName);
+            new AccessoryClass(this, existingAccessory, this.mqttClient);
+        }
+        else {
+            // Create new accessory
+            this.log.info('Adding new accessory:', name);
+            const accessory = new this.api.platformAccessory(name, uuid);
+            new AccessoryClass(this, accessory, this.mqttClient);
+            // Register the accessory
+            this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            this.accessories.push(accessory);
+        }
+    }
+    /**
+     * Remove accessories that are disabled in the configuration
+     */
+    removeDisabledAccessories(displayConfig) {
+        const enabledAccessories = [
+            displayConfig.showPowerMonitor ? 'Power Monitor' : null,
+            displayConfig.showEnergyMeter ? 'Energy Meter' : null,
+            displayConfig.showVoltageMonitor ? 'Voltage Monitor' : null,
+            displayConfig.showCurrentMonitor ? 'Current Monitor' : null,
+        ].filter((name) => name !== null);
+        const accessoriesToRemove = this.accessories.filter((accessory) => !enabledAccessories.includes(accessory.displayName));
+        accessoriesToRemove.forEach((accessory) => {
+            this.log.info('Removing accessory:', accessory.displayName);
+            this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+            const index = this.accessories.indexOf(accessory);
+            if (index > -1) {
+                this.accessories.splice(index, 1);
+            }
+        });
+    }
+    /**
+     * Cleanup resources on shutdown
+     */
+    cleanup() {
+        this.log.info('Shutting down platform, disconnecting from MQTT');
+        if (this.mqttClient) {
+            this.mqttClient.disconnect();
+        }
+    }
+}
+exports.EVNSmartmeterPlatform = EVNSmartmeterPlatform;

package/dist/settings.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This is the name of the platform that users will use to register the plugin in the Homebridge config.json
+ */
+export declare const PLATFORM_NAME = "EVNSmartmeter";
+/**
+ * This must match the name of your plugin as defined the package.json
+ */
+export declare const PLUGIN_NAME = "homebridge-evn-smartmeter";

package/dist/settings.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_NAME = exports.PLATFORM_NAME = void 0;
+/**
+ * This is the name of the platform that users will use to register the plugin in the Homebridge config.json
+ */
+exports.PLATFORM_NAME = 'EVNSmartmeter';
+/**
+ * This must match the name of your plugin as defined the package.json
+ */
+exports.PLUGIN_NAME = 'homebridge-evn-smartmeter';