homebridge-melcloud-control 4.1.2-beta.9 → 4.1.2

package/src/deviceerv.js

@@ -31,7 +31,8 @@ class DeviceErv extends EventEmitter {
         this.temperatureOutdoorSensor = device.temperatureOutdoorSensor || false;
         this.temperatureSupplySensor = device.temperatureSupplySensor || false;
         this.errorSensor = device.errorSensor || false;
-        this.presets = (device.presets || []).filter(preset => (preset.displayType ?? 0) > 0);
+        this.presets = this.accountType === 'melcloud' ? (device.presets || []).filter(preset => (preset.displayType ?? 0) > 0 && preset.id !== '0') : [];
+        this.schedules = this.accountType === 'melcloudhome' ? (device.schedules || []).filter(schedule => (schedule.displayType ?? 0) > 0 && schedule.id !== '0') : [];
         this.buttons = (device.buttonsSensors || []).filter(button => (button.displayType ?? 0) > 0);
         this.deviceId = device.id;
         this.deviceName = device.name;
@@ -55,6 +56,14 @@ class DeviceErv extends EventEmitter {
             preset.previousSettings = {};
         }
 
+        //schedules configured
+        for (const schedule of this.schedules) {
+            schedule.name = schedule.name || 'Schedule'
+            schedule.serviceType = [null, Service.Outlet, Service.Switch, Service.MotionSensor, Service.OccupancySensor, Service.ContactSensor][schedule.displayType];
+            schedule.characteristicType = [null, Characteristic.On, Characteristic.On, Characteristic.MotionDetected, Characteristic.OccupancyDetected, Characteristic.ContactSensorState][schedule.displayType];
+            schedule.state = false;
+        }
+
         //buttons configured
         for (const button of this.buttons) {
             button.name = button.name || 'Button'
@@ -230,6 +239,7 @@ class DeviceErv extends EventEmitter {
             const deviceName = this.deviceName;
             const accountName = this.accountName;
             const presetsOnServer = this.accessory.presets;
+            const schedulesOnServer = this.accessory.schedules;
             const hasRoomTemperature = this.accessory.hasRoomTemperature;
             const hasSupplyTemperature = this.accessory.hasSupplyTemperature;
             const hasOutdoorTemperature = this.accessory.hasOutdoorTemperature;
@@ -703,14 +713,14 @@ class DeviceErv extends EventEmitter {
                                         deviceData.Device.Power = presetData.Power;
                                         deviceData.Device.OperationMode = presetData.OperationMode;
                                         deviceData.Device.VentilationMode = presetData.VentilationMode;
-                                        deviceData.Device.SetFanSpeed = presetData.FanSpeed;
+                                        deviceData.Device.SetFanSpeed = presetData.SetFanSpeed;
                                         break;
                                     case false:
                                         deviceData.Device.SetTemperature = preset.previousSettings.SetTemperature;
                                         deviceData.Device.Power = preset.previousSettings.Power;
                                         deviceData.Device.OperationMode = preset.previousSettings.OperationMode;
                                         deviceData.Device.VentilationMode = preset.previousSettings.VentilationMode;
-                                        deviceData.Device.SetFanSpeed = preset.previousSettings.FanSpeed;
+                                        deviceData.Device.SetFanSpeed = preset.previousSettings.SetFanSpeed;
                                         break;
                                 };
 
@@ -725,6 +735,42 @@ class DeviceErv extends EventEmitter {
                 accessory.addService(presetService);
             };
 
+            //schedules services
+            if (this.schedules.length > 0) {
+                if (this.logDebug) this.emit('debug', `Prepare schedules services`);
+                this.schedulesServices = [];
+                this.schedules.forEach((schedule, i) => {
+                    //get preset name
+                    const name = schedule.name;
+
+                    //get preset name prefix
+                    const namePrefix = schedule.namePrefix;
+
+                    const serviceName = namePrefix ? `${accessoryName} ${name}` : name;
+                    const serviceType = schedule.serviceType;
+                    const characteristicType = schedule.characteristicType;
+                    const scheduleService = new serviceType(serviceName, `Schedule ${deviceId} ${i}`);
+                    scheduleService.addOptionalCharacteristic(Characteristic.ConfiguredName);
+                    scheduleService.setCharacteristic(Characteristic.ConfiguredName, serviceName);
+                    scheduleService.getCharacteristic(characteristicType)
+                        .onGet(async () => {
+                            const state = schedule.state;
+                            return state;
+                        })
+                        .onSet(async (state) => {
+                            try {
+                                deviceData.ScheduleEnabled = state;
+                                await this.melCloudAta.send(this.accountType, this.displayType, deviceData, 'scheduleset');
+                                if (this.logInfo) this.emit('info', `${state ? 'Set:' : 'Unset:'} ${name}`);
+                            } catch (error) {
+                                if (this.logWarn) this.emit('warn', `Set schedule error: ${error}`);
+                            };
+                        });
+                    this.schedulesServices.push(scheduleService);
+                    accessory.addService(scheduleService);
+                });
+            };
+
             //buttons services
             if (this.buttons.length > 0) {
                 if (this.logDebug) this.emit('debug', `Prepare buttons services`);
@@ -882,8 +928,10 @@ class DeviceErv extends EventEmitter {
                     const tempStepKey = this.accountType === 'melcloud' ? 'TemperatureIncrement' : 'HasHalfDegreeIncrements';
                     const errorKey = this.accountType === 'melcloud' ? 'HasError' : 'IsInError';
 
-                    //presets
-                    const presetsOnServer = deviceData[presetsKey] ?? [];
+                    //presets schedule
+                    const scheduleEnabled = deviceData.ScheduleEnabled;
+                    const schedulesOnServer = deviceData.Schedule ?? [];
+                    const presetsOnServer = deviceData.Presets ?? [];
 
                     //device control
                     const hideRoomTemperature = deviceData.HideRoomTemperature;
@@ -934,6 +982,7 @@ class DeviceErv extends EventEmitter {
                     //accessory
                     const obj = {
                         presets: presetsOnServer,
+                        schedules: schedulesOnServer,
                         hasRoomTemperature: hasRoomTemperature,
                         hasSupplyTemperature: hasSupplyTemperature,
                         hasOutdoorTemperature: hasOutdoorTemperature,
@@ -972,7 +1021,8 @@ class DeviceErv extends EventEmitter {
                         maxTempCoolDry: maxTempCoolDry,
                         useFahrenheit: this.useFahrenheit,
                         temperatureUnit: TemperatureDisplayUnits[this.useFahrenheit],
-                        isInError: isInError
+                        isInError: isInError,
+                        scheduleEnabled: scheduleEnabled
                     };
 
                     //ventilation mode - 0, HEAT, 2, COOL, 4, 5, 6, FAN, AUTO
@@ -1121,13 +1171,24 @@ class DeviceErv extends EventEmitter {
                                 && presetData.SetTemperature === setTemperature
                                 && presetData.OperationMode === operationMode
                                 && presetData.VentilationMode === ventilationMode
-                                && presetData.FanSpeed === setFanSpeed) : false;
+                                && presetData.SetFanSpeed === setFanSpeed) : false;
 
                             const characteristicType = preset.characteristicType;
                             this.presetsServices?.[i]?.updateCharacteristic(characteristicType, preset.state);
                         });
                     };
 
+                    //update schedules state
+                    if (this.schedules.length > 0) {
+                        this.schedules.forEach((schedule, i) => {
+                            const scheduleData = schedulesOnServer.find(s => s[presetsIdKey] === schedule.id);
+                            schedule.state = scheduleEnabled; //scheduleData.Enabled : false;
+
+                            const characteristicType = schedule.characteristicType;
+                            this.schedulesServices?.[i]?.updateCharacteristic(characteristicType, schedule.state);
+                        });
+                    };
+
                     //update buttons state
                     if (this.buttons.length > 0) {
                         this.buttons.forEach((button, i) => {

package/src/functions.js

@@ -68,18 +68,16 @@ class Functions extends EventEmitter {
             const arch = archOut.trim();
             if (this.logDebug) this.emit('debug', `Detected architecture: ${arch}`);
 
-            // --- Detect Docker environment ---
+            // --- Detect Docker ---
             let isDocker = false;
             try {
-                await access('/.dockerenv', fs.constants.F_OK);
-                isDocker = true;
-            } catch {
-                try {
-                    const { stdout } = await execPromise('cat /proc/1/cgroup || true');
-                    if (stdout.includes('docker') || stdout.includes('containerd'))
-                        isDocker = true;
-                } catch { }
-            }
+                await access('/.dockerenv', fs.constants.F_OK); isDocker = true;
+            } catch { }
+
+            try {
+                const { stdout } = await execPromise('cat /proc/1/cgroup || true');
+                if (stdout.includes('docker') || stdout.includes('containerd')) isDocker = true;
+            } catch { }
 
             if (isDocker && this.logDebug) this.emit('debug', 'Running inside Docker container.');
 
@@ -88,83 +86,68 @@ class Functions extends EventEmitter {
                 chromiumPath = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
                 try {
                     await access(chromiumPath, fs.constants.X_OK);
-                    if (this.logDebug) this.emit('debug', `Using system Chrome at ${chromiumPath}`);
                     return chromiumPath;
                 } catch {
                     return null;
                 }
             }
 
-            // === ARM (e.g. Raspberry Pi) ===
+            // === ARM ===
             if (arch.startsWith('arm')) {
                 try {
-                    await access('/usr/bin/chromium-browser', fs.constants.X_OK);
-                    if (this.logDebug) this.emit('debug', 'Using system Chromium on ARM platform.');
-                    return '/usr/bin/chromium-browser';
+                    chromiumPath = '/usr/bin/chromium-browser';
+                    await access(chromiumPath, fs.constants.X_OK);
+                    return chromiumPath;
                 } catch {
-                    if (this.logWarn) this.emit('warn', 'System Chromium not found on ARM. Attempting installation...');
                     try {
                         await execPromise('sudo apt-get update -y && sudo apt-get install -y chromium-browser chromium-codecs-ffmpeg');
-                        if (this.logDebug) this.emit('debug', 'Chromium installed successfully on ARM.');
-                        return '/usr/bin/chromium-browser';
+                        return chromiumPath;
                     } catch {
                         return null;
                     }
                 }
             }
 
-            // === Linux (x64, Docker, etc.) ===
+            // === Linux x64 ===
             if (osName === 'Linux') {
+                let systemChromium = null;
                 try {
-                    // --- Try detect common Chromium binaries ---
                     const { stdout: checkOut } = await execPromise('which chromium || which chromium-browser || true');
-                    chromiumPath = checkOut.trim();
-                    if (chromiumPath) {
-                        if (this.logDebug) this.emit('debug', `Found system Chromium: ${chromiumPath}`);
-                        return chromiumPath;
-                    }
+                    systemChromium = checkOut.trim() || null;
                 } catch { }
 
-                if (this.logWarn) this.emit('warn', 'Chromium not found. Attempting installation...');
-
-                // --- Try install (Docker-optimized first) ---
-                const installCommands = [
-                    'apt-get update -y && apt-get install -y chromium chromium-browser chromium-codecs-ffmpeg',
-                    'apk add --no-cache chromium ffmpeg',
-                    'yum install -y chromium chromium-codecs-ffmpeg'
-                ];
+                // --- Detect Entware (QNAP) ---
+                let entwareExists = false;
+                try {
+                    await access('/opt/bin/opkg', fs.constants.X_OK);
+                    entwareExists = true;
+                } catch { }
 
-                for (const cmd of installCommands) {
+                if (entwareExists) {
                     try {
-                        if (this.logDebug) this.emit('debug', `Trying installation: ${cmd}`);
-                        await execPromise(`sudo ${cmd}`);
-                        // Check for binary after install
-                        const { stdout: checkOut } = await execPromise('which chromium || which chromium-browser || true');
-                        chromiumPath = checkOut.trim() || '/usr/bin/chromium';
-                        if (chromiumPath) {
-                            if (this.logDebug) this.emit('debug', `Chromium installed successfully at ${chromiumPath}`);
-                            return chromiumPath;
-                        }
-                    } catch (error) {
-                        if (this.logDebug) this.emit('debug', `Install attempt failed: ${cmd} → ${error.message}`);
-                    }
+                        await execPromise('/opt/bin/opkg update');
+                        await execPromise('/opt/bin/opkg install nspr nss libx11 libxcomposite libxdamage libxrandr libatk libatk-bridge libcups libdrm libgbm libasound');
+                        process.env.LD_LIBRARY_PATH = `/opt/lib:${process.env.LD_LIBRARY_PATH || ''}`;
+                    } catch { }
                 }
 
-                if (isDocker) {
-                    // Docker fallback specific
+                // --- Generic Linux installs missing libs for Puppeteer ---
+                const depInstall = [
+                    'apt-get update -y && apt-get install -y libnspr4 libnss3 libx11-6 libxcomposite1 libxdamage1 libxrandr2 libatk1.0-0 libcups2 libdrm2 libgbm1 libasound2',
+                    'apk add --no-cache nspr nss libx11 libxcomposite libxdamage libxrandr atk cups libdrm libgbm alsa-lib',
+                    'yum install -y nspr nss libX11 libXcomposite libXdamage libXrandr atk cups libdrm libgbm alsa-lib'
+                ];
+                for (const cmd of depInstall) {
                     try {
-                        await execPromise('sudo apt-get update -y && sudo apt-get install -y chromium');
-                        await access('/usr/bin/chromium', fs.constants.X_OK);
-                        if (this.logDebug) this.emit('debug', 'Chromium installed successfully inside Docker at /usr/bin/chromium');
-                        return '/usr/bin/chromium';
-                    } catch {
-                        return null;
-                    }
+                        await execPromise(`sudo ${cmd}`);
+                    } catch { }
                 }
-                return null;
+
+                // Set LD_LIBRARY_PATH so Puppeteer's Chromium can find libs
+                process.env.LD_LIBRARY_PATH = `/usr/lib:/usr/lib64:${process.env.LD_LIBRARY_PATH || ''}`;
+                return systemChromium;
             }
 
-            // Unknown OS
             if (this.logDebug) this.emit('debug', `Unsupported OS: ${osName}.`);
             return null;
         } catch (error) {
@@ -172,5 +155,6 @@ class Functions extends EventEmitter {
             return null;
         }
     }
+
 }
 export default Functions

package/src/melcloud.js

@@ -1,8 +1,9 @@
+import fs from 'fs';
 import axios from 'axios';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import EventEmitter from 'events';
-import puppeteer from 'puppeteer-core';
+import puppeteer from 'puppeteer';
 import ImpulseGenerator from './impulsegenerator.js';
 import Functions from './functions.js';
 import { ApiUrls, ApiUrlsHome } from './constants.js';
@@ -235,61 +236,67 @@ class MelCloud extends EventEmitter {
             if (this.logDebug) this.emit('debug', `Buildings list saved`);
 
             const devices = buildingsList.flatMap(building => {
-                // Rekurencyjna funkcja kapitalizująca klucze w całym obiekcie
+                // Funkcja kapitalizująca klucze obiektu
+                const capitalizeKeys = obj =>
+                    Object.fromEntries(
+                        Object.entries(obj).map(([key, value]) => [
+                            key.charAt(0).toUpperCase() + key.slice(1),
+                            value
+                        ])
+                    );
+
+                // Rekurencyjna kapitalizacja kluczy w obiekcie lub tablicy
                 const capitalizeKeysDeep = obj => {
-                    if (Array.isArray(obj)) {
-                        return obj.map(item => capitalizeKeysDeep(item));
-                    } else if (obj && typeof obj === 'object' && obj.constructor === Object) {
+                    if (Array.isArray(obj)) return obj.map(capitalizeKeysDeep);
+                    if (obj && typeof obj === 'object') {
                         return Object.fromEntries(
-                            Object.entries(obj).map(([key, value]) => {
-                                const safeKey =
-                                    typeof key === 'string'
-                                        ? key.charAt(0).toUpperCase() + key.slice(1)
-                                        : key;
-                                return [safeKey, capitalizeKeysDeep(value)];
-                            })
+                            Object.entries(obj).map(([key, value]) => [
+                                key.charAt(0).toUpperCase() + key.slice(1),
+                                capitalizeKeysDeep(value)
+                            ])
                         );
                     }
                     return obj;
                 };
 
                 // Funkcja tworząca finalny obiekt Device
-                const createDevice = (device, type, headers = {}) => {
-                    const settingsArray = Array.isArray(device.Settings) ? device.Settings : [];
-
-                    // Parsowanie Settings → obiekt z poprawnymi typami i kapitalizacją
-                    const parsedSettings = Object.fromEntries(
-                        settingsArray
-                            .filter(s => s && typeof s.name === 'string')
-                            .map(({ name, value }) => {
-                                let parsedValue = value;
-                                if (value === 'True') parsedValue = true;
-                                else if (value === 'False') parsedValue = false;
-                                else if (
-                                    typeof value === 'string' &&
-                                    !isNaN(Number(value)) &&
-                                    value.trim() !== ''
-                                ) parsedValue = Number(value);
-
-                                const key =
-                                    name.charAt(0).toUpperCase() + name.slice(1);
-                                return [key, parsedValue];
-                            })
+                const createDevice = (device, type) => {
+                    // Settings już kapitalizowane w nazwach
+                    const settingsArray = device.Settings || [];
+
+                    const settingsObject = Object.fromEntries(
+                        settingsArray.map(({ name, value }) => {
+                            let parsedValue = value;
+                            if (value === "True") parsedValue = true;
+                            else if (value === "False") parsedValue = false;
+                            else if (!isNaN(value) && value !== "") parsedValue = Number(value);
+
+                            const key = name.charAt(0).toUpperCase() + name.slice(1);
+                            return [key, parsedValue];
+                        })
                     );
 
-                    // Połącz Capabilities + Settings + DeviceType
+                    // Scal Capabilities + Settings + DeviceType w Device
                     const deviceObject = {
-                        ...capitalizeKeysDeep(device.Capabilities || {}),
-                        ...parsedSettings,
+                        ...capitalizeKeys(device.Capabilities || {}),
+                        ...settingsObject,
                         DeviceType: type
                     };
 
-                    // Usuń pola, które nie mają trafić do finalnego obiektu
+                    // Kapitalizacja brakujących obiektów/tablic
+                    if (device.FrostProtection) device.FrostProtection = { ...capitalizeKeys(device.FrostProtection || {}) };
+                    if (device.OverheatProtection) device.OverheatProtection = { ...capitalizeKeys(device.OverheatProtection || {}) };
+                    if (device.HolidayMode) device.HolidayMode = { ...capitalizeKeys(device.HolidayMode || {}) };
+
+                    if (Array.isArray(device.Schedule)) {
+                        device.Schedule = device.Schedule.map(capitalizeKeysDeep);
+                    }
+
+                    // Usuń stare pola Settings i Capabilities
                     const { Settings, Capabilities, Id, GivenDisplayName, ...rest } = device;
 
-                    // Zwróć gotowy obiekt urządzenia
                     return {
-                        ...capitalizeKeysDeep(rest),
+                        ...rest,
                         Type: type,
                         DeviceID: Id,
                         DeviceName: GivenDisplayName,
@@ -298,14 +305,11 @@ class MelCloud extends EventEmitter {
                     };
                 };
 
-                // Mapowanie urządzeń w budynku
                 return [
-                    ...(building.airToAirUnits || []).map(d => createDevice(capitalizeKeysDeep(d), 0)),
-                    ...(building.airToWaterUnits || []).map(d => createDevice(capitalizeKeysDeep(d), 1)),
-                    ...(building.airToVentilationUnits || []).map(d => createDevice(capitalizeKeysDeep(d), 3))
+                    ...(building.airToAirUnits || []).map(d => createDevice(capitalizeKeys(d), 0)),
+                    ...(building.airToWaterUnits || []).map(d => createDevice(capitalizeKeys(d), 1)),
+                    ...(building.airToVentilationUnits || []).map(d => createDevice(capitalizeKeys(d), 3))
                 ];
-
-
             });
 
             const devicesCount = devices.length;
@@ -333,7 +337,21 @@ class MelCloud extends EventEmitter {
         let browser;
         try {
             const accountInfo = { State: false, Info: '', ContextKey: null, UseFahrenheit: false };
-            const chromiumPath = await this.functions.ensureChromiumInstalled();
+            let chromiumPath = await this.functions.ensureChromiumInstalled();
+
+            // === Fallback to Puppeteer's built-in Chromium ===
+            if (!chromiumPath) {
+                try {
+                    const puppeteerPath = puppeteer.executablePath();
+                    if (puppeteerPath && fs.existsSync(puppeteerPath)) {
+                        chromiumPath = puppeteerPath;
+                        if (this.logDebug) this.emit('debug', `Using puppeteer Chromium at ${chromiumPath}`);
+                    }
+                } catch { }
+            } else {
+                if (this.logDebug) this.emit('debug', `Using system Chromium at ${chromiumPath}`);
+            }
+
             if (!chromiumPath) {
                 accountInfo.Info = 'Chromium not found on Your device, please install it manually and try again';
                 return accountInfo;
@@ -343,7 +361,6 @@ class MelCloud extends EventEmitter {
             try {
                 const { stdout } = await execPromise(`"${chromiumPath}" --version`);
                 if (this.logDebug) this.emit('debug', `Chromium detected: ${stdout.trim()}`);
-                if (this.logDebug) this.emit('debug', `Chromium detected: ${stdout.trim()}`);
             } catch (error) {
                 accountInfo.Info = `Chromium found at ${chromiumPath}, but cannot be executed: ${error.message}`;
                 return accountInfo;

package/src/melcloudata.js

@@ -23,7 +23,6 @@ class MelCloudAta extends EventEmitter {
 
         //set default values
         this.deviceData = {};
-        this.headers = {};
 
         //lock flags
         this.locks = {
@@ -60,7 +59,7 @@ class MelCloudAta extends EventEmitter {
                 return null;
             }
             const deviceData = devicesData.find(device => device.DeviceID === this.deviceId);
-            this.headers = deviceData.Headers;
+
             if (this.accountType === 'melcloudhome') {
                 deviceData.SerialNumber = deviceData.DeviceID || '4.0.0';
                 deviceData.Device.FirmwareAppVersion = deviceData.ConnectedInterfaceIdentifier || '4.0.0';
@@ -75,7 +74,12 @@ class MelCloudAta extends EventEmitter {
                 deviceData.Device.DefaultHeatingSetTemperature = temps?.defaultHeatingSetTemperature ?? 20;
                 deviceData.Device.DefaultCoolingSetTemperature = temps?.defaultCoolingSetTemperature ?? 24;
             }
-            if (this.logDebug) this.emit('debug', `Device Data: ${JSON.stringify(deviceData, null, 2)}`);
+
+            const safeConfig = {
+                ...deviceData,
+                headers: 'removed',
+            };
+            if (this.logDebug) this.emit('debug', `Device Data: ${JSON.stringify(safeConfig, null, 2)}`);
 
             //device
             const serialNumber = deviceData.SerialNumber;
@@ -144,7 +148,7 @@ class MelCloudAta extends EventEmitter {
                         method: 'POST',
                         baseURL: ApiUrls.BaseURL,
                         timeout: 10000,
-                        headers: this.headers,
+                        headers: deviceData.Headers,
                         withCredentials: true
                     });
 
@@ -183,7 +187,7 @@ class MelCloudAta extends EventEmitter {
                         method: 'PUT',
                         baseURL: ApiUrlsHome.BaseURL,
                         timeout: 10000,
-                        headers: this.headers,
+                        headers: deviceData.Headers,
                         withCredentials: true
                     });
 
@@ -199,19 +203,19 @@ class MelCloudAta extends EventEmitter {
                         }
                     }
 
-                    const settings = {
+                    const settings = effectiveFlags === 'scheduleset' ? { data: { enabled: deviceData.ScheduleEnabled } } : {
                         data: {
                             Power: deviceData.Device.Power,
                             SetTemperature: deviceData.Device.SetTemperature,
                             SetFanSpeed: String(deviceData.Device.SetFanSpeed),
                             OperationMode: AirConditioner.OperationModeMapEnumToString[deviceData.Device.OperationMode],
                             VaneHorizontalDirection: AirConditioner.VaneHorizontalDirectionMapEnumToString[deviceData.Device.VaneHorizontalDirection],
-                            VaneVerticalDirection: AirConditioner.VaneVerticalDirectionMapEnumToString[deviceData.Device.VaneVerticalDirection]
+                            VaneVerticalDirection: AirConditioner.VaneVerticalDirectionMapEnumToString[deviceData.Device.VaneVerticalDirection],
                         }
                     };
                     if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(settings.data, null, 2)}`);
 
-                    const path = ApiUrlsHome.SetAta.replace('deviceid', deviceData.DeviceID);
+                    const path = effectiveFlags === 'scheduleset' ? ApiUrlsHome.SetSchedule.replace('deviceid', deviceData.DeviceID) : ApiUrlsHome.SetAta.replace('deviceid', deviceData.DeviceID);
                     await axiosInstancePut(path, settings);
                     this.updateData(deviceData);
                     return true;
@@ -219,6 +223,11 @@ class MelCloudAta extends EventEmitter {
                     return;
             }
         } catch (error) {
+            // Return 500 for schedule hovewer working correct
+            if (error?.response?.status === 500) {
+                return true;
+            }
+
             throw new Error(`Send data error: ${error.message}`);
         }
     }

package/src/melcloudatw.js

@@ -23,7 +23,6 @@ class MelCloudAtw extends EventEmitter {
 
         //set default values
         this.devicesData = {};
-        this.headers = {};
 
         //lock flags
         this.locks = {
@@ -55,19 +54,21 @@ class MelCloudAtw extends EventEmitter {
         try {
             //read device info from file
             const devicesData = await this.functions.readData(this.devicesFile, true);
-
             if (!Array.isArray(devicesData)) {
                 if (this.logWarn) this.emit('warn', `Device data not found`);
                 return null;
             }
             const deviceData = devicesData.find(device => device.DeviceID === this.deviceId);
-            this.headers = deviceData.Headers;
 
             if (this.accountType === 'melcloudhome') {
                 deviceData.SerialNumber = deviceData.DeviceID || '4.0.0';
                 deviceData.Device.FirmwareAppVersion = deviceData.ConnectedInterfaceIdentifier || '4.0.0';
             }
-            if (this.logDebug) this.emit('debug', `Device Data: ${JSON.stringify(deviceData, null, 2)}`);
+            const safeConfig = {
+                ...deviceData,
+                headers: 'removed',
+            };
+            if (this.logDebug) this.emit('debug', `Device Data: ${JSON.stringify(safeConfig, null, 2)}`);
 
             //device
             const serialNumber = deviceData.SerialNumber;
@@ -152,7 +153,7 @@ class MelCloudAtw extends EventEmitter {
                         method: 'POST',
                         baseURL: ApiUrls.BaseURL,
                         timeout: 10000,
-                        headers: this.headers,
+                        headers: deviceData.Headers,
                         withCredentials: true
                     });
 
@@ -190,11 +191,11 @@ class MelCloudAtw extends EventEmitter {
                         method: 'PUT',
                         baseURL: ApiUrlsHome.BaseURL,
                         timeout: 10000,
-                        headers: this.headers,
+                        headers: deviceData.Headers,
                         withCredentials: true
                     });
 
-                    const settings = {
+                    const settings = effectiveFlags === 'scheduleset' ? { data: { enabled: deviceData.ScheduleEnabled } } : {
                         data: {
                             Power: deviceData.Device.Power,
                             SetTemperatureZone1: deviceData.Device.SetTemperatureZone1,
@@ -213,7 +214,7 @@ class MelCloudAtw extends EventEmitter {
                     };
                     if (this.logDebug) this.emit('debug', `Send Data: ${JSON.stringify(settings.data, null, 2)}`);
 
-                    const path = ApiUrlsHome.SetAtw.replace('deviceid', deviceData.DeviceID);
+                    const path = effectiveFlags === 'scheduleset' ? ApiUrlsHome.SetSchedule.replace('deviceid', deviceData.DeviceID) : ApiUrlsHome.SetAtw.replace('deviceid', deviceData.DeviceID);
                     await axiosInstancePut(path, settings);
                     this.updateData(deviceData);
                     return true;
@@ -221,6 +222,11 @@ class MelCloudAtw extends EventEmitter {
                     return;
             }
         } catch (error) {
+            // Return 500 for schedule hovewer working correct
+            if (error?.response?.status === 500) {
+                return true;
+            }
+            
             throw new Error(`Send data error: ${error.message}`);
         }
     }