iobroker.loxone 3.0.1 → 4.0.0

package/src/controls/Colorpicker.ts

@@ -0,0 +1,30 @@
+import type { Control } from '../structure-file';
+import { ColorpickerBase } from './ColorpickerBase';
+import type { ControlType } from './control-base';
+
+/**
+ * Handler for Colorpicker controls.
+ */
+export class Colorpicker extends ColorpickerBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'light.color.rgb',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['color', 'favorites']);
+
+        await this.loadColorPickerControlBaseAsync(uuid, control);
+    }
+}

package/src/controls/ColorpickerBase.ts

@@ -0,0 +1,326 @@
+import type { RGB } from 'color-convert';
+import colorConvert from 'color-convert';
+import type { CurrentStateValue } from '../main';
+import type { Control } from '../structure-file';
+import { ControlBase } from './control-base';
+
+/**
+ * Base class for color picker controls.
+ */
+export abstract class ColorpickerBase extends ControlBase {
+    private colorUpdateTimer?: NodeJS.Timeout;
+
+    /**
+     * Loads the color picker control and sets up state objects and event handlers.
+     *
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     * @returns A promise that resolves when the loading is complete.
+     */
+    protected async loadColorPickerControlBaseAsync(uuid: string, control: Control): Promise<void> {
+        if (!control.states || !('color' in control.states)) {
+            return;
+        }
+
+        if (control.details.pickerType === 'Rgb') {
+            await this.loadRgbColorPickerAsync(uuid, control);
+        } else if (control.details.pickerType === 'Lumitech') {
+            await this.loadLumitechColorPickerAsync(uuid, control);
+        } else {
+            throw new Error(`Unsupported color picker type: ${control.details.pickerType as string}`);
+        }
+    }
+
+    private async loadRgbColorPickerAsync(uuid: string, control: Control): Promise<void> {
+        await this.updateStateObjectAsync(
+            `${uuid}.red`,
+            {
+                name: `${control.name}: red`,
+                read: true,
+                write: true,
+                type: 'number',
+                role: 'level.color.red',
+                min: 0,
+                max: 255,
+                // TODO: re-add: smartIgnore: true,
+            },
+            control.states.color,
+            async (name: string, value: CurrentStateValue) => {
+                const rgb = this.loxoneColorToRgb(value);
+                if (rgb !== undefined) {
+                    await this.setStateAck(name, rgb[0]);
+                }
+            },
+        );
+        await this.updateStateObjectAsync(
+            `${uuid}.green`,
+            {
+                name: `${control.name}: green`,
+                read: true,
+                write: true,
+                type: 'number',
+                role: 'level.color.green',
+                min: 0,
+                max: 255,
+                // TODO: re-add: smartIgnore: true,
+            },
+            control.states.color,
+            async (name: string, value: CurrentStateValue) => {
+                const rgb = this.loxoneColorToRgb(value);
+                if (rgb !== undefined) {
+                    await this.setStateAck(name, rgb[1]);
+                }
+            },
+        );
+        await this.updateStateObjectAsync(
+            `${uuid}.blue`,
+            {
+                name: `${control.name}: blue`,
+                read: true,
+                write: true,
+                type: 'number',
+                role: 'level.color.blue',
+                min: 0,
+                max: 255,
+                // TODO: re-add: smartIgnore: true,
+            },
+            control.states.color,
+            async (name: string, value: CurrentStateValue) => {
+                const rgb = this.loxoneColorToRgb(value);
+                if (rgb !== undefined) {
+                    await this.setStateAck(name, rgb[2]);
+                }
+            },
+        );
+        await this.updateStateObjectAsync(
+            `${uuid}.rgb`,
+            {
+                name: `${control.name}: RGB`,
+                read: true,
+                write: false,
+                type: 'string',
+                role: 'level.color.rgb',
+                // TODO: re-add: smartIgnore: true,
+            },
+            control.states.color,
+            async (name: string, value: CurrentStateValue) => {
+                const rgb = this.loxoneColorToRgb(value);
+                if (rgb !== undefined) {
+                    await this.setStateAck(name, `${rgb[0]},${rgb[1]},${rgb[2]}`);
+                }
+            },
+        );
+        await this.updateStateObjectAsync(
+            `${uuid}.level`,
+            {
+                name: `${control.name}: Level (only with colorTemperature)`,
+                read: true,
+                write: false,
+                type: 'number',
+                role: 'level.color.level',
+                min: 0,
+                max: 100,
+                // TODO: re-add: smartIgnore: true,
+            },
+            control.states.color,
+            async (name: string, value: CurrentStateValue) => {
+                const brightnessTemperature = this.lumitechOrLoxoneColorToBrightnessTemperature(value);
+                if (brightnessTemperature !== undefined) {
+                    await this.setStateAck(name, brightnessTemperature[0]);
+                }
+            },
+        );
+        await this.updateStateObjectAsync(
+            `${uuid}.colorTemperature`,
+            {
+                name: `${control.name}: The temperature of the light in °K 2700-6500`,
+                read: true,
+                write: false,
+                type: 'number',
+                role: 'level.color.temperature',
+                // TODO: re-add: smartIgnore: true,
+            },
+            control.states.color,
+            async (name: string, value: CurrentStateValue) => {
+                const brightnessTemperature = this.lumitechOrLoxoneColorToBrightnessTemperature(value);
+                if (brightnessTemperature !== undefined) {
+                    await this.setStateAck(name, brightnessTemperature[1]);
+                }
+            },
+        );
+        await this.updateStateObjectAsync(
+            `${uuid}.colorTemperatureHue`,
+            {
+                name: `${control.name}: The temperature of the light in °K scaled for Hue 2000-6500`,
+                read: true,
+                write: false,
+                type: 'number',
+                role: 'level.color.temperature',
+                // TODO: re-add: smartIgnore: true,
+            },
+            control.states.color,
+            async (name: string, value: CurrentStateValue) => {
+                const brightnessTemperature = this.lumitechOrLoxoneColorToBrightnessTemperature(value);
+                if (brightnessTemperature !== undefined) {
+                    await this.setStateAck(
+                        name,
+                        Math.round((brightnessTemperature[1] - 2700) * 1.184210526315789 + 2000),
+                    );
+                }
+            },
+        );
+
+        // we use a timer (100 ms) to update the three color values,
+        // so if somebody sends us the three values (almost) at once,
+        // we don't change the color three times using commands
+        const parentId = `${this.adapter.namespace}.${uuid}`;
+        const updateColorValue = async (): Promise<void> => {
+            const states = await this.adapter.getStatesAsync(`${uuid}.*`);
+            const red = this.convertStateToInt(states[`${parentId}.red`].val);
+            const green = this.convertStateToInt(states[`${parentId}.green`].val);
+            const blue = this.convertStateToInt(states[`${parentId}.blue`].val);
+
+            const hsv = colorConvert.rgb.hsv([red, green, blue]);
+            const command = `hsv(${hsv[0]},${hsv[1]},${hsv[2]})`;
+            this.sendCommand(control.uuidAction, command);
+        };
+        const startUpdateTimer = (): void => {
+            if (this.colorUpdateTimer) {
+                clearTimeout(this.colorUpdateTimer);
+            }
+            this.colorUpdateTimer = setTimeout(updateColorValue, 100);
+        };
+        this.addStateChangeListener(`${uuid}.red`, startUpdateTimer);
+        this.addStateChangeListener(`${uuid}.green`, startUpdateTimer);
+        this.addStateChangeListener(`${uuid}.blue`, startUpdateTimer);
+    }
+
+    private async loadLumitechColorPickerAsync(uuid: string, control: Control): Promise<void> {
+        await this.updateStateObjectAsync(
+            `${uuid}.brightness`,
+            {
+                name: `${control.name}: Brightness`,
+                read: true,
+                write: true,
+                type: 'number',
+                role: 'level.color.level',
+                min: 0,
+                max: 100,
+                // TODO: re-add: smartIgnore: true,
+            },
+            control.states.color,
+            async (name: string, value: CurrentStateValue) => {
+                const brightnessTemperature = this.lumitechOrLoxoneColorToBrightnessTemperature(value);
+                if (brightnessTemperature !== undefined) {
+                    await this.setStateAck(name, brightnessTemperature[0]);
+                }
+            },
+        );
+        await this.updateStateObjectAsync(
+            `${uuid}.temperature`,
+            {
+                name: `${control.name}: Temperature`,
+                read: true,
+                write: true,
+                type: 'number',
+                role: 'level.color.temperature',
+                min: 2000,
+                max: 8000,
+                // TODO: re-add: smartIgnore: true,
+            },
+            control.states.color,
+            async (name: string, value: CurrentStateValue) => {
+                const brightnessTemperature = this.lumitechOrLoxoneColorToBrightnessTemperature(value);
+                if (brightnessTemperature !== undefined) {
+                    await this.setStateAck(name, brightnessTemperature[1]);
+                }
+            },
+        );
+
+        // we use a timer (100 ms) to update the two color values,
+        // so if somebody sends us the two values (almost) at once,
+        // we don't change the color twice using commands
+        const parentId = `${this.adapter.namespace}.${uuid}`;
+        const updateColorValue = async (): Promise<void> => {
+            const states = await this.adapter.getStatesAsync(`${uuid}.*`);
+            const brightness = this.convertStateToInt(states[`${parentId}.brightness`].val);
+            const temperature = this.convertStateToInt(states[`${parentId}.temperature`].val);
+
+            const command = `lumitech(${brightness},${temperature})`;
+            this.sendCommand(control.uuidAction, command);
+        };
+        const startUpdateTimer = (): void => {
+            if (this.colorUpdateTimer) {
+                clearTimeout(this.colorUpdateTimer);
+            }
+            this.colorUpdateTimer = setTimeout(updateColorValue, 100);
+        };
+        this.addStateChangeListener(`${uuid}.brightness`, startUpdateTimer);
+        this.addStateChangeListener(`${uuid}.temperature`, startUpdateTimer);
+    }
+
+    private loxoneColorToRgb(value: CurrentStateValue): RGB | undefined {
+        if (!value) {
+            return undefined;
+        }
+
+        value = value.toString();
+        let match = value.match(/hsv\((\d+),(\d+),(\d+)\)/i);
+        if (match) {
+            const hue = parseInt(match[1]);
+            const sat = parseInt(match[2]);
+            const val = parseInt(match[3]);
+
+            return colorConvert.hsv.rgb([hue, sat, val]);
+        }
+
+        match = value.match(/temp\((\d+),(\d+)\)/i);
+        if (match) {
+            const brightness = parseFloat(match[1]) / 100;
+            const temperature = parseFloat(match[2]) / 100;
+
+            // based on http://www.tannerhelland.com/4435/convert-temperature-rgb-algorithm-code/
+            let red = 255;
+            let green = 255;
+            let blue = 255;
+
+            if (temperature <= 66) {
+                green = 99.4708025861 * Math.log(temperature) - 161.1195681661;
+                if (temperature <= 19) {
+                    blue = 0;
+                } else {
+                    blue = 138.5177312231 * Math.log(temperature - 10) - 305.0447927307;
+                }
+            } else {
+                red = 329.698727446 * Math.pow(temperature - 60, -0.1332047592);
+                green = 288.1221695283 * Math.pow(temperature - 60, -0.0755148492);
+            }
+
+            red = Math.min(Math.max(red, 0), 255) * brightness;
+            green = Math.min(Math.max(green, 0), 255) * brightness;
+            blue = Math.min(Math.max(blue, 0), 255) * brightness;
+
+            return [Math.round(red), Math.round(green), Math.round(blue)];
+        }
+
+        return undefined;
+    }
+
+    private lumitechOrLoxoneColorToBrightnessTemperature(value: CurrentStateValue): [number, number] | undefined {
+        if (!value) {
+            return undefined;
+        }
+
+        value = value.toString();
+
+        const match = value.match(/(lumitech|temp)\((\d+),(\d+)\)/i);
+        if (match) {
+            const brightness = parseFloat(match[1]);
+            const temperature = parseFloat(match[2]);
+
+            return [Math.round(brightness), Math.round(temperature)];
+        }
+
+        return undefined;
+    }
+}

package/src/controls/Daytimer.ts

@@ -0,0 +1,201 @@
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for Daytimer controls.
+ */
+export class Daytimer extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'timer',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, [
+            'mode',
+            'override',
+            'value',
+            'needsActivation',
+            'modeList',
+            'entriesAndDefaultValue',
+            'resetActive',
+        ]);
+
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'mode', 'number', 'value');
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'override',
+            'number',
+            'value',
+            { unit: 'sec' },
+        );
+
+        // value is a number for analog daytimers and a boolean for digital ones
+        if (control.details.analog) {
+            await this.createSimpleControlStateObjectAsync(
+                control.name,
+                uuid,
+                control.states,
+                'value',
+                'number',
+                'value',
+            );
+
+            if ('format' in control.details) {
+                await this.updateStateObjectAsync(
+                    `${uuid}.value-formatted`,
+                    {
+                        name: `${control.name}: formatted value`,
+                        read: true,
+                        write: false,
+                        type: 'string',
+                        role: 'text',
+                        // TODO: re-add: smartIgnore: true,
+                    },
+                    control.states.value,
+                    async (name: string, value: any) => {
+                        await this.setFormattedStateAck(name, value, control.details.format as string);
+                    },
+                );
+            }
+        } else {
+            await this.createSimpleControlStateObjectAsync(
+                control.name,
+                uuid,
+                control.states,
+                'value',
+                'boolean',
+                'indicator',
+            );
+
+            if ('text' in control.details) {
+                const text = control.details?.text as
+                    | {
+                          /** The text to display when the value is on */
+                          on: string;
+                          /** The text to display when the value is off */
+                          off: string;
+                      }
+                    | undefined;
+                await this.updateStateObjectAsync(
+                    `${uuid}.value-formatted`,
+                    {
+                        name: `${control.name}: formatted value`,
+                        read: true,
+                        write: false,
+                        type: 'string',
+                        role: 'text',
+                        // TODO: re-add: smartIgnore: true,
+                    },
+                    control.states.value,
+                    async (name: string, value: any) => {
+                        await this.setStateAck(
+                            name,
+                            (this.convertStateToBoolean(value) ? text?.on : text?.off) || null,
+                        );
+                    },
+                );
+            }
+        }
+
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'needsActivation',
+            'boolean',
+            'indicator',
+        );
+
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'resetActive',
+            'boolean',
+            'indicator',
+        );
+
+        if ('mode' in control.states && 'modeList' in control.states) {
+            const obj: ioBroker.SettableObjectWorker<ioBroker.StateObject> = {
+                type: 'state',
+                common: {
+                    name: `${control.name}: mode as text`,
+                    read: true,
+                    write: false,
+                    type: 'string',
+                    role: 'text',
+                    // TODO: re-add: smartIgnore: true,
+                },
+                native: {
+                    mode: control.states.mode,
+                    modeList: control.states.modeList,
+                },
+            };
+            await this.updateObjectAsync(`${uuid}.mode-text`, obj);
+
+            let modeNames: Record<string, string> = {};
+            let mode = '-';
+            const updateModeText = async (): Promise<void> => {
+                if (mode in modeNames) {
+                    await this.setStateAck(`${uuid}.mode-text`, modeNames[mode]);
+                }
+            };
+            this.addStateEventHandler(control.states.mode, async (value: ioBroker.StateValue) => {
+                mode = this.convertStateToInt(value).toString();
+                await updateModeText();
+            });
+            this.addStateEventHandler(control.states.modeList, async (value: ioBroker.StateValue) => {
+                if (!value) {
+                    return;
+                }
+
+                // format of value: 0:mode=0;name=\"Feiertag\",1:mode=1;name=\"Urlaub\"
+                modeNames = value
+                    .toString()
+                    .split(',')
+                    .map(item =>
+                        item
+                            .split(':', 2)[1]
+                            .split(';')
+                            .map(pair => pair.split('=', 2)),
+                    )
+                    .reduce(
+                        (old, pairs) => {
+                            const modePair = pairs.find(p => p[0] === 'mode');
+                            const namePair = pairs.find(p => p[0] === 'name');
+                            if (!modePair || !namePair) {
+                                return old;
+                            }
+                            return { ...old, [modePair[1]]: namePair[1].replace(/^\\?"(.+?)\\?"$/g, '$1') };
+                        },
+                        {} as Record<string, string>,
+                    );
+                await updateModeText();
+            });
+        }
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'pulse');
+        this.addStateChangeListener(
+            `${uuid}.pulse`,
+            () => {
+                this.sendCommand(control.uuidAction, 'pulse');
+            },
+            { selfAck: true },
+        );
+    }
+}

package/src/controls/Dimmer.ts

@@ -0,0 +1,64 @@
+import type { CurrentStateValue, OldStateValue } from '../main';
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for Dimmer controls.
+ */
+export class Dimmer extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'light',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['position', 'min', 'max', 'step']);
+
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'position',
+            'number',
+            'level.dimmer',
+            { write: true },
+        );
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'min', 'number', 'value');
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'max', 'number', 'value');
+        await this.createSimpleControlStateObjectAsync(control.name, uuid, control.states, 'step', 'number', 'value');
+
+        this.addStateChangeListener(`${uuid}.position`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, this.convertStateToInt(newValue).toString());
+        });
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'on');
+        this.addStateChangeListener(
+            `${uuid}.on`,
+            () => {
+                this.sendCommand(control.uuidAction, 'on');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'off');
+        this.addStateChangeListener(
+            `${uuid}.off`,
+            () => {
+                this.sendCommand(control.uuidAction, 'off');
+            },
+            { selfAck: true },
+        );
+    }
+}

package/src/controls/EIBDimmer.ts

@@ -0,0 +1,61 @@
+import type { CurrentStateValue, OldStateValue } from '../main';
+import type { Control } from '../structure-file';
+import type { ControlType } from './control-base';
+import { ControlBase } from './control-base';
+
+/**
+ * Handler for EIBDimmer controls.
+ */
+export class EIBDimmer extends ControlBase {
+    /**
+     * Loads the control and sets up state objects and event handlers.
+     *
+     * @param type The type of the control ('device' or 'channel').
+     * @param uuid The unique identifier of the control.
+     * @param control The control data from the structure file.
+     */
+    async loadAsync(type: ControlType, uuid: string, control: Control): Promise<void> {
+        await this.updateObjectAsync(uuid, {
+            type: type,
+            common: {
+                name: control.name,
+                role: 'light',
+            },
+            native: { control },
+        });
+
+        await this.loadOtherControlStatesAsync(control.name, uuid, control.states, ['position']);
+
+        await this.createSimpleControlStateObjectAsync(
+            control.name,
+            uuid,
+            control.states,
+            'position',
+            'number',
+            'level.dimmer',
+            { write: true },
+        );
+
+        this.addStateChangeListener(`${uuid}.position`, (oldValue: OldStateValue, newValue: CurrentStateValue) => {
+            this.sendCommand(control.uuidAction, this.convertStateToInt(newValue).toString());
+        });
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'on');
+        this.addStateChangeListener(
+            `${uuid}.on`,
+            () => {
+                this.sendCommand(control.uuidAction, 'on');
+            },
+            { selfAck: true },
+        );
+
+        await this.createButtonCommandStateObjectAsync(control.name, uuid, 'off');
+        this.addStateChangeListener(
+            `${uuid}.off`,
+            () => {
+                this.sendCommand(control.uuidAction, 'off');
+            },
+            { selfAck: true },
+        );
+    }
+}