homebridge-tsvesync 1.0.72 → 1.0.76

package/dist/accessories/air-purifier.accessory.js

@@ -4,16 +4,190 @@ exports.AirPurifierAccessory = void 0;
 const base_accessory_1 = require("./base.accessory");
 class AirPurifierAccessory extends base_accessory_1.BaseAccessory {
     constructor(platform, accessory, device) {
-        var _a;
         super(platform, accessory, device);
+        this.lastSetSpeed = 0; // Track the last speed we set
+        this.lastSetPercentage = 0; // Track the last percentage we set
+        this.skipNextUpdate = false; // Flag to skip the next update
         this.device = device;
         this.capabilities = this.getDeviceCapabilities();
-        // Detect if this is an LV-series device (LV-PUR131S or LV-RH131S)
+        // Detect device class based on model number patterns
         const extendedDevice = this.device;
-        this.isLVSeries = ((_a = extendedDevice.deviceType) === null || _a === void 0 ? void 0 : _a.startsWith('LV-')) || false;
-        if (this.isLVSeries) {
-            this.platform.log.debug(`Detected LV-series device: ${this.device.deviceName} (${extendedDevice.deviceType})`);
+        const deviceType = extendedDevice.deviceType || '';
+        // AirBypass Devices: Core series, LAP-C series, Vital series
+        this.isAirBypassDevice = deviceType.includes('CORE') ||
+            deviceType.startsWith('LAP-C') ||
+            deviceType.includes('VITAL');
+        // AirBaseV2 Devices: LAP-V series, LAP-EL series, EverestAir series
+        this.isAirBaseV2Device = deviceType.startsWith('LAP-V') ||
+            deviceType.startsWith('LAP-EL') ||
+            deviceType.includes('EVERESTAIR');
+        // Air131 Devices: LV-PUR131S, LV-RH131S
+        this.isAir131Device = deviceType.startsWith('LV-');
+        // Log device class detection
+        if (this.isAirBypassDevice) {
+            this.platform.log.debug(`Detected AirBypass device: ${this.device.deviceName} (${deviceType})`);
         }
+        else if (this.isAirBaseV2Device) {
+            this.platform.log.debug(`Detected AirBaseV2 device: ${this.device.deviceName} (${deviceType})`);
+        }
+        else if (this.isAir131Device) {
+            this.platform.log.debug(`Detected Air131 device: ${this.device.deviceName} (${deviceType})`);
+        }
+        else {
+            this.platform.log.debug(`Unknown air purifier type: ${this.device.deviceName} (${deviceType})`);
+        }
+    }
+    /**
+     * Feature detection system
+     */
+    hasFeature(feature) {
+        const extendedDevice = this.device;
+        // Use device's native hasFeature method if available
+        if (typeof extendedDevice.hasFeature === 'function') {
+            return extendedDevice.hasFeature(feature);
+        }
+        // Fallback feature detection based on device type
+        switch (feature) {
+            case 'air_quality':
+                // Explicitly disable air quality features
+                return false;
+            case 'child_lock':
+                // Explicitly disable child lock features
+                return false;
+            case 'display':
+                // Explicitly disable display control features
+                return false;
+            case 'filter_life':
+                // Explicitly disable filter life reporting
+                return false;
+            case 'fan_speed':
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Check if a feature is supported in the current device mode
+     */
+    isFeatureSupportedInCurrentMode(feature) {
+        const extendedDevice = this.device;
+        // Use device's native method if available
+        if (typeof extendedDevice.isFeatureSupportedInCurrentMode === 'function') {
+            return extendedDevice.isFeatureSupportedInCurrentMode(feature);
+        }
+        // Fallback logic
+        const mode = extendedDevice.mode || 'manual';
+        // Air131 only supports fan speed in manual mode
+        if (feature === 'fan_speed' && this.isAir131Device && mode !== 'manual') {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get the maximum fan speed for the device
+     */
+    getMaxFanSpeed() {
+        const extendedDevice = this.device;
+        // Use device's native method if available
+        if (typeof extendedDevice.getMaxFanSpeed === 'function') {
+            const maxSpeed = extendedDevice.getMaxFanSpeed();
+            if (typeof maxSpeed === 'number' && maxSpeed > 0) {
+                return maxSpeed;
+            }
+        }
+        // Use maxSpeed property if available
+        if (typeof extendedDevice.maxSpeed === 'number' && extendedDevice.maxSpeed > 0) {
+            return extendedDevice.maxSpeed;
+        }
+        // Fallback logic based on device type
+        if (this.isAir131Device) {
+            return 3; // LV-series devices have 3 speed levels
+        }
+        else if (this.isAirBypassDevice) {
+            return 3; // All Core series have 3 speed levels
+        }
+        else if (this.isAirBaseV2Device) {
+            if (this.device.deviceType.includes('LAP-EL551S')) {
+                return 3; // LAP-EL551S has 3 speed levels
+            }
+            else {
+                return 4; // LAP-V series have 4 speed levels
+            }
+        }
+        // Default to 3 for unknown devices
+        return 3;
+    }
+    /**
+     * Convert device speed to percentage
+     */
+    speedToPercentage(speed) {
+        const maxSpeed = this.getMaxFanSpeed();
+        // Ensure we have valid numbers
+        if (maxSpeed <= 0 || typeof speed !== 'number' || speed <= 0) {
+            return 0;
+        }
+        // For devices with 3 speed levels
+        if (maxSpeed === 3) {
+            switch (speed) {
+                case 1: return 33; // Low -> 33%
+                case 2: return 67; // Medium -> 67%
+                case 3: return 100; // High -> 100%
+                default: return 0;
+            }
+        }
+        // For devices with 4 speed levels
+        else if (maxSpeed === 4) {
+            switch (speed) {
+                case 1: return 25; // Low -> 25%
+                case 2: return 50; // Medium-Low -> 50%
+                case 3: return 75; // Medium-High -> 75%
+                case 4: return 100; // High -> 100%
+                default: return 0;
+            }
+        }
+        // Default calculation
+        return Math.min(100, Math.max(0, Math.round((speed / maxSpeed) * 100)));
+    }
+    /**
+     * Convert percentage to device speed
+     */
+    percentageToSpeed(percentage) {
+        const maxSpeed = this.getMaxFanSpeed();
+        // Ensure we have valid numbers
+        if (maxSpeed <= 0 || typeof percentage !== 'number') {
+            return 1; // Default to lowest speed
+        }
+        // Ensure percentage is between 0 and 100
+        percentage = Math.min(100, Math.max(0, percentage));
+        // For devices with 3 speed levels
+        if (maxSpeed === 3) {
+            if (percentage <= 33) {
+                return 1; // Low
+            }
+            else if (percentage <= 67) {
+                return 2; // Medium
+            }
+            else {
+                return 3; // High
+            }
+        }
+        // For devices with 4 speed levels
+        else if (maxSpeed === 4) {
+            if (percentage <= 25) {
+                return 1; // Low
+            }
+            else if (percentage <= 50) {
+                return 2; // Medium-Low
+            }
+            else if (percentage <= 75) {
+                return 3; // Medium-High
+            }
+            else {
+                return 4; // High
+            }
+        }
+        // Default calculation
+        return Math.max(1, Math.min(Math.round((percentage / 100) * maxSpeed), maxSpeed));
     }
     /**
      * Set up the air purifier service
@@ -25,11 +199,110 @@ class AirPurifierAccessory extends base_accessory_1.BaseAccessory {
         // Set up required characteristics
         this.setupCharacteristic(this.platform.Characteristic.Active, this.getActive.bind(this), this.setActive.bind(this));
         // Set up target state characteristic for mode mapping
-        this.setupCharacteristic(this.platform.Characteristic.TargetAirPurifierState, this.getTargetState.bind(this), this.setTargetState.bind(this));
-        // Set up speed control
-        this.setupCharacteristic(this.platform.Characteristic.RotationSpeed, this.getRotationSpeed.bind(this), this.handleSetRotationSpeed.bind(this));
+        const targetStateChar = this.service.getCharacteristic(this.platform.Characteristic.TargetAirPurifierState);
+        // For Core200S, only allow manual mode
+        if (this.device.deviceType.includes('Core200S')) {
+            targetStateChar.setProps({
+                validValues: [0] // MANUAL only
+            });
+        }
+        else if (this.device.deviceType.includes('Core300S')) {
+            // Explicitly ensure Core300S has both AUTO and MANUAL modes
+            // Force the mode toggle to be visible for Core300S devices
+            this.platform.log.debug(`Explicitly enabling mode toggle for Core300S device: ${this.device.deviceName}`);
+            // First remove any existing characteristic to ensure clean setup
+            if (this.service.testCharacteristic(this.platform.Characteristic.TargetAirPurifierState)) {
+                this.service.removeCharacteristic(this.service.getCharacteristic(this.platform.Characteristic.TargetAirPurifierState));
+            }
+            // Re-add the characteristic with proper properties
+            const newTargetStateChar = this.service.addCharacteristic(this.platform.Characteristic.TargetAirPurifierState);
+            newTargetStateChar.setProps({
+                validValues: [0, 1],
+                perms: ["pr" /* this.platform.Characteristic.Perms.PAIRED_READ */, "pw" /* this.platform.Characteristic.Perms.PAIRED_WRITE */, "ev" /* this.platform.Characteristic.Perms.NOTIFY */]
+            });
+            // Set up the characteristic handlers
+            newTargetStateChar.onGet(async () => {
+                try {
+                    const value = await this.getTargetState();
+                    return value;
+                }
+                catch (error) {
+                    this.platform.log.error(`Error getting target state: ${error}`);
+                    throw error;
+                }
+            });
+            newTargetStateChar.onSet(async (value) => {
+                try {
+                    await this.setTargetState(value);
+                }
+                catch (error) {
+                    this.platform.log.error(`Error setting target state: ${error}`);
+                    throw error;
+                }
+            });
+        }
+        else {
+            targetStateChar.setProps({
+                validValues: [0, 1] // MANUAL and AUTO
+            });
+            // Set up the characteristic handlers for non-Core300S devices
+            this.setupCharacteristic(this.platform.Characteristic.TargetAirPurifierState, this.getTargetState.bind(this), this.setTargetState.bind(this));
+        }
+        // Set up current state
+        this.setupCharacteristic(this.platform.Characteristic.CurrentAirPurifierState, this.getCurrentState.bind(this));
+        // Set up speed control with special handling for Core200S and Core300S
+        if (this.device.deviceType.includes('Core200S') || this.device.deviceType.includes('Core300S')) {
+            // For Core200S and Core300S, set up rotation speed characteristic manually
+            this.platform.log.debug(`Explicitly setting up rotation speed for ${this.device.deviceName}`);
+            // First remove any existing characteristic to ensure clean setup
+            if (this.service.testCharacteristic(this.platform.Characteristic.RotationSpeed)) {
+                this.service.removeCharacteristic(this.service.getCharacteristic(this.platform.Characteristic.RotationSpeed));
+            }
+            // Re-add the characteristic with proper properties
+            const rotationSpeedChar = this.service.addCharacteristic(this.platform.Characteristic.RotationSpeed);
+            rotationSpeedChar.setProps({
+                minValue: 0,
+                maxValue: 100,
+                minStep: 1,
+                perms: ["pr" /* this.platform.Characteristic.Perms.PAIRED_READ */, "pw" /* this.platform.Characteristic.Perms.PAIRED_WRITE */, "ev" /* this.platform.Characteristic.Perms.NOTIFY */]
+            });
+            // Set up the characteristic handlers
+            rotationSpeedChar.onGet(async () => {
+                try {
+                    const value = await this.getRotationSpeed();
+                    this.platform.log.debug(`${this.device.deviceName} getRotationSpeed returned: ${value}`);
+                    return value;
+                }
+                catch (error) {
+                    this.platform.log.error(`Error getting rotation speed: ${error}`);
+                    throw error;
+                }
+            });
+            rotationSpeedChar.onSet(async (value) => {
+                try {
+                    this.platform.log.debug(`${this.device.deviceName} setRotationSpeed called with: ${value}`);
+                    await this.setRotationSpeed(value);
+                }
+                catch (error) {
+                    this.platform.log.error(`Error setting rotation speed: ${error}`);
+                    throw error;
+                }
+            });
+        }
+        else {
+            // For other devices, use the standard setup
+            this.setupCharacteristic(this.platform.Characteristic.RotationSpeed, this.getRotationSpeed.bind(this), this.setRotationSpeed.bind(this));
+        }
         // Add Name characteristic
         this.setupCharacteristic(this.platform.Characteristic.Name, async () => this.device.deviceName);
+        // Air quality sensor service has been disabled for all devices
+    }
+    // Air quality sensor service has been removed
+    /**
+     * Get current state (INACTIVE = 0, IDLE = 1, PURIFYING_AIR = 2)
+     */
+    async getCurrentState() {
+        return this.device.deviceStatus === 'on' ? 2 : 0;
     }
     /**
      * Get device capabilities
@@ -37,8 +310,8 @@ class AirPurifierAccessory extends base_accessory_1.BaseAccessory {
     getDeviceCapabilities() {
         return {
             hasSpeed: true,
-            hasAirQuality: true,
-            hasChildLock: true,
+            hasAirQuality: this.hasFeature('air_quality'),
+            hasChildLock: false,
             hasBrightness: false,
             hasColorTemp: false,
             hasColor: false,
@@ -58,61 +331,73 @@ class AirPurifierAccessory extends base_accessory_1.BaseAccessory {
         this.service.updateCharacteristic(this.platform.Characteristic.CurrentAirPurifierState, isOn ? 2 : 0);
         // Get the extended device to access mode information
         const extendedDevice = this.device;
-        // Update target state (AUTO = 0, MANUAL = 1)
-        // If mode is available, use it to determine target state
-        let targetState = 1; // Default to MANUAL
-        if (extendedDevice.mode) {
-            targetState = extendedDevice.mode === 'auto' ? 0 : 1;
+        // Update target state (MANUAL = 0, AUTO = 1)
+        // Special handling for Core200S
+        let targetState = 0; // Default to MANUAL
+        if (this.device.deviceType.includes('Core200S')) {
+            // Core200S always reports MANUAL mode
+            targetState = 0; // MANUAL
+        }
+        else if (extendedDevice.mode) {
+            // For other devices, including Core300S, use the reported mode
+            targetState = extendedDevice.mode === 'auto' ? 1 : 0;
         }
         this.service.updateCharacteristic(this.platform.Characteristic.TargetAirPurifierState, targetState);
         // Update rotation speed
-        let rotationSpeed = 0;
-        if (isOn && details.speed !== undefined) {
-            if (this.isLVSeries) {
-                // For LV-series devices, speed is limited to 1-3
-                // Convert device speed (1-3) to HomeKit percentage (0-100)
-                switch (details.speed) {
-                    case 1:
-                        rotationSpeed = 33;
-                        break; // Low
-                    case 2:
-                        rotationSpeed = 66;
-                        break; // Medium
-                    case 3:
-                        rotationSpeed = 100;
-                        break; // High
+        if (isOn && details.speed !== undefined && details.speed !== null) {
+            // Check if we should skip this update
+            if (this.skipNextUpdate) {
+                this.platform.log.debug(`Skipping update for ${this.device.deviceName} as requested`);
+                this.skipNextUpdate = false;
+                return;
+            }
+            // If we've recently set the speed, use the percentage we calculated
+            if (this.lastSetSpeed > 0 && this.lastSetPercentage > 0) {
+                this.platform.log.debug(`Using last set percentage for ${this.device.deviceName}: speed=${this.lastSetSpeed}, percentage=${this.lastSetPercentage}`);
+                // Only update if the device speed matches what we set
+                if (this.lastSetSpeed === details.speed) {
+                    this.platform.log.debug(`Device speed matches last set speed: ${details.speed}`);
+                    // Force update the characteristic to our last set percentage
+                    this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, this.lastSetPercentage);
+                }
+                else {
+                    // Device speed doesn't match what we set, so convert from device speed
+                    const percentage = this.speedToPercentage(details.speed);
+                    this.platform.log.debug(`Device speed doesn't match last set speed. Device: ${details.speed}, Last set: ${this.lastSetSpeed}, Calculated percentage: ${percentage}`);
+                    // Update our tracking variables
+                    this.lastSetSpeed = details.speed;
+                    this.lastSetPercentage = percentage;
+                    // Update the characteristic
+                    this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, percentage);
                 }
             }
             else {
-                // For standard devices, speed can be 1-5
-                // Convert device speed (1-5) to HomeKit percentage (0-100)
-                switch (details.speed) {
-                    case 1:
-                        rotationSpeed = 20;
-                        break; // Sleep
-                    case 2:
-                        rotationSpeed = 40;
-                        break; // Low
-                    case 3:
-                        rotationSpeed = 60;
-                        break; // Medium
-                    case 4:
-                        rotationSpeed = 80;
-                        break; // High
-                    case 5:
-                        rotationSpeed = 100;
-                        break; // Turbo
-                }
+                // No recent set speed, so convert from device speed
+                const percentage = this.speedToPercentage(details.speed);
+                this.platform.log.debug(`No recent set speed for ${this.device.deviceName}. Device speed: ${details.speed}, Calculated percentage: ${percentage}`);
+                // Update the characteristic
+                this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, percentage);
             }
         }
-        this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, rotationSpeed);
+        else {
+            this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, 0);
+            // Reset tracking variables when device is off
+            this.lastSetSpeed = 0;
+            this.lastSetPercentage = 0;
+        }
+        // Air quality updates have been removed
     }
     /**
-     * Get target state (AUTO = 0, MANUAL = 1)
+     * Get target state (MANUAL = 0, AUTO = 1)
      */
     async getTargetState() {
+        // For Core200S, always return MANUAL
+        if (this.device.deviceType.includes('Core200S')) {
+            return 0; // MANUAL
+        }
         const extendedDevice = this.device;
-        return extendedDevice.mode === 'auto' ? 0 : 1;
+        const targetState = extendedDevice.mode === 'auto' ? 1 : 0;
+        return targetState;
     }
     /**
      * Set target state (AUTO = 0, MANUAL = 1)
@@ -121,15 +406,22 @@ class AirPurifierAccessory extends base_accessory_1.BaseAccessory {
         try {
             const targetState = value;
             const extendedDevice = this.device;
-            // Map HomeKit target states to device modes
-            const mode = targetState === 0 ? 'auto' : 'manual';
+            // For Core200S, don't allow mode changes
+            if (this.device.deviceType.includes('Core200S')) {
+                this.platform.log.warn(`Mode changes not supported on ${this.device.deviceName}, only fan speed control is available`);
+                // Update the characteristic back to MANUAL (0)
+                this.service.updateCharacteristic(this.platform.Characteristic.TargetAirPurifierState, 0);
+                return;
+            }
+            // For all other devices, including Core300S, normal mode handling
+            const mode = targetState === 1 ? 'auto' : 'manual';
             this.platform.log.debug(`Setting mode to ${mode} for device: ${this.device.deviceName}`);
             let success = false;
             // Use the appropriate method to set the mode
-            if (targetState === 0 && typeof extendedDevice.autoMode === 'function') {
+            if (targetState === 1 && typeof extendedDevice.autoMode === 'function') {
                 success = await extendedDevice.autoMode();
             }
-            else if (targetState === 1 && typeof extendedDevice.manualMode === 'function') {
+            else if (targetState === 0 && typeof extendedDevice.manualMode === 'function') {
                 success = await extendedDevice.manualMode();
             }
             else if (typeof extendedDevice.setMode === 'function') {
@@ -152,11 +444,38 @@ class AirPurifierAccessory extends base_accessory_1.BaseAccessory {
         }
     }
     /**
-     * Handle set rotation speed
+     * Get rotation speed
      */
-    async handleSetRotationSpeed(value) {
+    async getRotationSpeed() {
+        // If device is off or speed is not defined, return 0
+        if (this.device.deviceStatus !== 'on' ||
+            this.device.speed === undefined ||
+            this.device.speed === null) {
+            return 0;
+        }
+        // If we have a last set percentage, use that instead of calculating from device speed
+        if (this.lastSetPercentage > 0 && this.lastSetSpeed === this.device.speed) {
+            this.platform.log.debug(`getRotationSpeed returning last set percentage: ${this.lastSetPercentage} for speed: ${this.device.speed}`);
+            return this.lastSetPercentage;
+        }
+        // Convert device speed to percentage using our consistent conversion method
+        const percentage = this.speedToPercentage(this.device.speed);
+        this.platform.log.debug(`getRotationSpeed calculated percentage: ${percentage} for speed: ${this.device.speed}`);
+        return percentage;
+    }
+    /**
+     * Set rotation speed
+     */
+    async setRotationSpeed(value) {
         try {
-            const percentage = value;
+            // Ensure value is a valid number
+            let percentage = value;
+            if (isNaN(percentage) || percentage === null || percentage === undefined) {
+                this.platform.log.warn(`Invalid rotation speed value: ${value} for device: ${this.device.deviceName}`);
+                return;
+            }
+            // Ensure percentage is between 0 and 100
+            percentage = Math.min(100, Math.max(0, percentage));
             this.platform.log.debug(`Setting rotation speed to ${percentage}% for device: ${this.device.deviceName}`);
             if (percentage === 0) {
                 // Turn off the device instead of setting speed to 0
@@ -165,62 +484,56 @@ class AirPurifierAccessory extends base_accessory_1.BaseAccessory {
                 if (!success) {
                     throw new Error('Failed to turn off device');
                 }
+                // Reset tracking variables when turning off
+                this.lastSetSpeed = 0;
+                this.lastSetPercentage = 0;
                 return;
             }
             const extendedDevice = this.device;
-            // For LV-series devices, ensure the device is in manual mode before changing fan speed
-            if (this.isLVSeries && extendedDevice.mode !== 'manual') {
-                this.platform.log.debug(`Setting device to manual mode before changing fan speed: ${this.device.deviceName}`);
-                // Use the appropriate method to set manual mode
-                if (typeof extendedDevice.manualMode === 'function') {
-                    const modeSuccess = await extendedDevice.manualMode();
-                    this.platform.log.debug(`Set manual mode result: ${modeSuccess ? 'success' : 'failed'}`);
-                }
-                else if (typeof extendedDevice.setMode === 'function') {
-                    const modeSuccess = await extendedDevice.setMode('manual');
-                    this.platform.log.debug(`Set manual mode result: ${modeSuccess ? 'success' : 'failed'}`);
+            // Check if fan speed control is supported in current mode
+            if (!this.isFeatureSupportedInCurrentMode('fan_speed')) {
+                this.platform.log.warn(`Fan speed control not supported in ${extendedDevice.mode} mode for device: ${this.device.deviceName}`);
+                // For Air131 devices, switch to manual mode first
+                if (this.isAir131Device && extendedDevice.mode !== 'manual') {
+                    this.platform.log.debug(`Setting device to manual mode before changing fan speed: ${this.device.deviceName}`);
+                    // Use the appropriate method to set manual mode
+                    if (typeof extendedDevice.manualMode === 'function') {
+                        const modeSuccess = await extendedDevice.manualMode();
+                        this.platform.log.debug(`Set manual mode result: ${modeSuccess ? 'success' : 'failed'}`);
+                    }
+                    else if (typeof extendedDevice.setMode === 'function') {
+                        const modeSuccess = await extendedDevice.setMode('manual');
+                        this.platform.log.debug(`Set manual mode result: ${modeSuccess ? 'success' : 'failed'}`);
+                    }
                 }
             }
-            let speed;
-            if (this.isLVSeries) {
-                // For LV-series devices, speed is limited to 1-3
-                // Convert HomeKit percentage (0-100) to device speed (1-3)
-                if (percentage <= 33) {
-                    speed = 1; // Low
-                }
-                else if (percentage <= 66) {
-                    speed = 2; // Medium
-                }
-                else {
-                    speed = 3; // High
-                }
-            }
-            else {
-                // For standard devices, speed can be 1-5
-                // Convert HomeKit percentage (0-100) to device speed (1-5)
-                if (percentage <= 20) {
-                    speed = 1; // Sleep
-                }
-                else if (percentage <= 40) {
-                    speed = 2; // Low
-                }
-                else if (percentage <= 60) {
-                    speed = 3; // Medium
-                }
-                else if (percentage <= 80) {
-                    speed = 4; // High
-                }
-                else {
-                    speed = 5; // Turbo
-                }
+            // Convert percentage to device speed using our consistent conversion method
+            const speed = this.percentageToSpeed(percentage);
+            // Final validation to ensure speed is a valid number
+            if (isNaN(speed) || speed === null || speed === undefined) {
+                this.platform.log.warn(`Calculated invalid speed: ${speed} from percentage: ${percentage} for device: ${this.device.deviceName}`);
+                return;
             }
             this.platform.log.debug(`Setting fan speed to ${speed} for device: ${this.device.deviceName}`);
+            // Store the values we're setting before making the API call
+            this.lastSetSpeed = speed;
+            this.lastSetPercentage = percentage;
+            // Set the flag to skip the next update
+            this.skipNextUpdate = true;
+            // Immediately update the characteristic to show the correct percentage
+            // This ensures the slider shows the value we set, not what the device reports
+            this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, percentage);
             const success = await this.device.changeFanSpeed(speed);
             if (!success) {
+                // If the API call failed, reset our tracking variables
+                this.lastSetSpeed = 0;
+                this.lastSetPercentage = 0;
                 throw new Error(`Failed to set speed to ${speed}`);
             }
+            this.platform.log.debug(`Successfully set fan speed to ${speed} (${percentage}%) for device: ${this.device.deviceName}`);
             // Update device state and characteristics
-            await this.updateDeviceSpecificStates(this.device);
+            // Skip this to avoid overriding our UI update
+            // await this.updateDeviceSpecificStates(this.device);
         }
         catch (error) {
             this.handleDeviceError('set rotation speed', error);
@@ -237,6 +550,11 @@ class AirPurifierAccessory extends base_accessory_1.BaseAccessory {
             if (!success) {
                 throw new Error(`Failed to turn ${isOn ? 'on' : 'off'} device`);
             }
+            // Reset tracking variables when turning off
+            if (!isOn) {
+                this.lastSetSpeed = 0;
+                this.lastSetPercentage = 0;
+            }
             // Update device state and characteristics
             await this.updateDeviceSpecificStates(this.device);
             await this.persistDeviceState('deviceStatus', isOn ? 'on' : 'off');
@@ -245,35 +563,6 @@ class AirPurifierAccessory extends base_accessory_1.BaseAccessory {
             this.handleDeviceError('set active state', error);
         }
     }
-    async getRotationSpeed() {
-        if (this.device.speed === undefined || this.device.speed === null) {
-            return 0;
-        }
-        if (this.isLVSeries) {
-            // For LV-series devices, speed is limited to 1-3
-            // Convert device speed (1-3) to HomeKit percentage (0-100)
-            switch (this.device.speed) {
-                case 0: return 0; // Off
-                case 1: return 33; // Low
-                case 2: return 66; // Medium
-                case 3: return 100; // High
-                default: return 0;
-            }
-        }
-        else {
-            // For standard devices, speed can be 1-5
-            // Convert device speed (1-5) to HomeKit percentage (0-100)
-            switch (this.device.speed) {
-                case 0: return 0; // Off
-                case 1: return 20; // Sleep
-                case 2: return 40; // Low
-                case 3: return 60; // Medium
-                case 4: return 80; // High
-                case 5: return 100; // Turbo
-                default: return 0;
-            }
-        }
-    }
 }
 exports.AirPurifierAccessory = AirPurifierAccessory;
 //# sourceMappingURL=air-purifier.accessory.js.map