@homebridge-plugins/homebridge-smarthq 0.5.0-beta.21 → 0.5.0-beta.23

package/dist/devices/refrigerator.js

@@ -1,38 +1,172 @@
 import { interval, skipWhile } from 'rxjs';
 import { ERD_TYPES } from '../settings.js';
 import { deviceBase } from './device.js';
+/**
+ * SmartHQ Refrigerator - Unified HAP/Matter Implementation
+ * Supports both HomeKit Accessory Protocol and Matter protocol
+ */
 export class SmartHQRefrigerator extends deviceBase {
     platform;
     device;
     // Updates
     SensorUpdateInProgress;
     deviceStatus;
+    // Matter support override flag
+    useMatterOverride = false;
     constructor(platform, accessory, device) {
         super(platform, accessory, device);
         this.platform = platform;
         this.device = device;
+        // Check if we should use Matter protocol
+        this.useMatterOverride = device.useMatter ?? false;
         this.debugLog(`Refrigerator Features: ${JSON.stringify(accessory.context.device.features)}`);
-        // DOOR_STATUS ERD returns hex string where each byte represents a door compartment
-        // Format: "XXYYZZ..." where XX=byte0, YY=byte1, etc.
-        // 0xFF = not available/unused, 0x00 = closed, 0x01 = open
-        // Byte mapping for this fridge model:
-        //   byte0 (pos 0-1) = Fridge Right Door
-        //   byte1 (pos 2-3) = Fridge Left Door
-        //   byte2 (pos 4-5) = Freezer Door
-        //   byte3 (pos 6-7) = Unused (0xFF)
-        // Check which door bytes are available (not 0xFF)
+        this.debugLog(`Using protocol: ${this.useMatterOverride ? 'Matter' : 'HAP'}`);
+        // Initialize the appropriate protocol
+        if (this.useMatterOverride) {
+            this.initializeMatter();
+        }
+        else {
+            this.initializeHAP();
+        }
+        // Start periodic refresh
+        this.SensorUpdateInProgress = false;
+        interval(this.deviceRefreshRate * 1000)
+            .pipe(skipWhile(() => this.SensorUpdateInProgress))
+            .subscribe(async () => {
+            await this.refreshDeviceStatus();
+        });
+        // Initial refresh after 2 seconds
+        setTimeout(() => this.refreshDeviceStatus(), 2000);
+    }
+    /**
+     * Initialize Matter protocol
+     */
+    initializeMatter() {
+        const matterAPI = this.api.matter;
+        if (!matterAPI) {
+            this.errorLog('Matter API not available');
+            return;
+        }
+        const serialNumber = this.device.applianceId || 'unknown';
+        this.matterUuid = matterAPI.uuid.generate(serialNumber);
+        // Create Matter accessory configuration with refrigerator-specific clusters
+        const matterAccessory = {
+            UUID: this.matterUuid,
+            displayName: this.device.nickname || 'SmartHQ Refrigerator',
+            serialNumber,
+            manufacturer: this.device.brand && this.device.brand !== 'Unknown' ? this.device.brand : 'GE Appliances',
+            model: this.device.model || 'SmartHQ',
+            firmwareRevision: this.deviceFirmwareVersion,
+            hardwareRevision: this.deviceFirmwareVersion,
+            deviceType: matterAPI.deviceTypes.RefrigeratorFreezer,
+            clusters: {
+                // Temperature control for main compartment
+                thermostat: {
+                    localTemperature: 400, // 4°C in 0.01°C units
+                    occupiedCoolingSetpoint: 400,
+                    systemMode: 3, // COOL
+                    thermostatRunningMode: 3,
+                    controlSequenceOfOperation: 2, // cooling only
+                },
+                temperatureMeasurement: {
+                    measuredValue: 400, // 4°C
+                    minMeasuredValue: 0, // 0°C
+                    maxMeasuredValue: 720, // 7.2°C
+                },
+                // Refrigerator and Temperature Controlled Cabinet Mode Cluster (0x0052)
+                refrigeratorAndTemperatureControlledCabinetMode: {
+                    mode: 0, // 0=Normal, 1=RapidCool, 2=RapidFreeze
+                },
+                // Refrigerator Alarm Cluster (0x0057)
+                refrigeratorAlarm: {
+                    mask: 0, // Bitmap: bit 0=door open, bit 1=temp high, bit 2=temp low
+                    state: 0, // Current alarm state
+                    supported: 7, // Support door, temp high, temp low alarms
+                },
+            },
+            // Multi-endpoint structure for fridge and freezer compartments
+            parts: [
+                // Fridge compartment endpoint
+                {
+                    UUID: matterAPI.uuid.generate(`${serialNumber}-fridge`),
+                    displayName: 'Fridge Compartment',
+                    serialNumber: `${serialNumber}-fridge`,
+                    manufacturer: this.device.brand || 'GE Appliances',
+                    model: `${this.device.model || 'SmartHQ'} Fridge`,
+                    deviceType: matterAPI.deviceTypes.TemperatureSensor,
+                    clusters: {
+                        temperatureMeasurement: {
+                            measuredValue: 400, // 4°C
+                            minMeasuredValue: 0,
+                            maxMeasuredValue: 720,
+                        },
+                        // Boolean state for ice maker
+                        booleanState: {
+                            stateValue: false, // Ice maker state
+                        },
+                        // Resource monitoring for water filter
+                        resourceMonitoring: {
+                            condition: 100, // 100% = OK, 0% = needs replacement
+                            degradationDirection: 1, // 1 = down (degrades over time)
+                            changeIndication: 0, // 0=OK, 1=Warning, 2=Critical
+                            productIdentifierType: 0, // 0=UPC, 1=GTIN8, 2=EAN, 3=GTIN14
+                            productIdentifierValue: 'FILTER',
+                        },
+                    },
+                },
+                // Freezer compartment endpoint
+                {
+                    UUID: matterAPI.uuid.generate(`${serialNumber}-freezer`),
+                    displayName: 'Freezer Compartment',
+                    serialNumber: `${serialNumber}-freezer`,
+                    manufacturer: this.device.brand || 'GE Appliances',
+                    model: `${this.device.model || 'SmartHQ'} Freezer`,
+                    deviceType: matterAPI.deviceTypes.TemperatureSensor,
+                    clusters: {
+                        temperatureMeasurement: {
+                            measuredValue: -1800, // -18°C
+                            minMeasuredValue: -2100,
+                            maxMeasuredValue: -330,
+                        },
+                        // Boolean state for turbo freeze
+                        booleanState: {
+                            stateValue: false, // Turbo freeze state
+                        },
+                    },
+                },
+            ],
+            handlers: {
+                thermostat: {
+                    setpointRaiseLower: async (request) => {
+                        await this.handleMatterSetpointChange(request);
+                    },
+                },
+                refrigeratorAndTemperatureControlledCabinetMode: {
+                    changeToMode: async (request) => {
+                        await this.handleMatterModeChange(request);
+                    },
+                },
+            },
+        };
+        // Register Matter accessory
+        matterAPI.registerAccessory(matterAccessory);
+        this.infoLog('Created Matter Refrigerator with advanced clusters and multi-endpoint structure');
+    }
+    /**
+     * Initialize HAP (HomeKit) protocol
+     */
+    initializeHAP() {
+        // Helper functions for parsing ERD values
         const checkDoorAvailability = async () => {
             const r = await this.readErd(ERD_TYPES.DOOR_STATUS);
             if (!r || r.length < 2) {
                 return { byte0: false, byte1: false, byte2: false };
             }
             try {
-                // Parse hex bytes - each byte is 2 characters
                 const byte0 = r.substring(0, 2);
                 const byte1 = r.substring(2, 4);
                 const byte2 = r.substring(4, 6);
                 this.debugLog(`Door status bytes: byte0=${byte0}, byte1=${byte1}, byte2=${byte2}`);
-                // A byte is available if it exists and isn't 0xFF (unused)
                 return {
                     byte0: byte0 !== 'FF' && byte0 !== '',
                     byte1: byte1 !== 'FF' && byte1 !== '' && byte1 !== undefined,
@@ -44,7 +178,6 @@ export class SmartHQRefrigerator extends deviceBase {
                 return { byte0: false, byte1: false, byte2: false };
             }
         };
-        // Helper to parse individual door byte
         const parseDoorByte = async (byteIndex) => {
             const r = await this.readErd(ERD_TYPES.DOOR_STATUS);
             if (!r) {
@@ -54,7 +187,7 @@ export class SmartHQRefrigerator extends deviceBase {
                 const byteValue = r.substring(byteIndex * 2, byteIndex * 2 + 2);
                 const state = Number.parseInt(byteValue, 16);
                 this.debugLog(`Door byte${byteIndex} value: ${byteValue} = ${state}`);
-                return state !== 0; // 0 = closed, anything else = open
+                return state !== 0;
             }
             catch (parseError) {
                 this.debugLog(`Door byte${byteIndex} parse error: ${parseError}`);
@@ -66,48 +199,52 @@ export class SmartHQRefrigerator extends deviceBase {
             const availableDoors = await checkDoorAvailability();
             // Byte 0: Fridge Right Door
             if (availableDoors.byte0) {
-                const doorService = this.accessory.getService('Fridge Right Door') ?? this.accessory.addService(this.platform.Service.ContactSensor, 'Fridge Right Door', 'FridgeRightDoor');
-                doorService.setCharacteristic(this.platform.Characteristic.Name, 'Fridge Right Door');
-                doorService
+                const fridgeRightDoor = this.accessory.getService('Fridge Right Door') ?? this.accessory.addService(this.platform.Service.ContactSensor, 'Fridge Right Door', 'FridgeRightDoor');
+                fridgeRightDoor.setCharacteristic(this.platform.Characteristic.Name, 'Fridge Right Door');
+                fridgeRightDoor
                     .getCharacteristic(this.platform.Characteristic.ContactSensorState)
-                    .onGet(async () => parseDoorByte(0));
+                    .onGet(async () => {
+                    const isOpen = await parseDoorByte(0);
+                    return isOpen ? this.platform.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED : this.platform.Characteristic.ContactSensorState.CONTACT_DETECTED;
+                });
             }
             // Byte 1: Fridge Left Door
             if (availableDoors.byte1) {
-                const door2Service = this.accessory.getService('Fridge Left Door') ?? this.accessory.addService(this.platform.Service.ContactSensor, 'Fridge Left Door', 'FridgeLeftDoor');
-                door2Service.setCharacteristic(this.platform.Characteristic.Name, 'Fridge Left Door');
-                door2Service
+                const fridgeLeftDoor = this.accessory.getService('Fridge Left Door') ?? this.accessory.addService(this.platform.Service.ContactSensor, 'Fridge Left Door', 'FridgeLeftDoor');
+                fridgeLeftDoor.setCharacteristic(this.platform.Characteristic.Name, 'Fridge Left Door');
+                fridgeLeftDoor
                     .getCharacteristic(this.platform.Characteristic.ContactSensorState)
-                    .onGet(async () => parseDoorByte(1));
+                    .onGet(async () => {
+                    const isOpen = await parseDoorByte(1);
+                    return isOpen ? this.platform.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED : this.platform.Characteristic.ContactSensorState.CONTACT_DETECTED;
+                });
             }
             // Byte 2: Freezer Door
             if (availableDoors.byte2) {
-                const door3Service = this.accessory.getService('Freezer Door') ?? this.accessory.addService(this.platform.Service.ContactSensor, 'Freezer Door', 'FreezerDoor');
-                door3Service.setCharacteristic(this.platform.Characteristic.Name, 'Freezer Door');
-                door3Service
+                const freezerDoor = this.accessory.getService('Freezer Door') ?? this.accessory.addService(this.platform.Service.ContactSensor, 'Freezer Door', 'FreezerDoor');
+                freezerDoor.setCharacteristic(this.platform.Characteristic.Name, 'Freezer Door');
+                freezerDoor
                     .getCharacteristic(this.platform.Characteristic.ContactSensorState)
-                    .onGet(async () => parseDoorByte(2));
+                    .onGet(async () => {
+                    const isOpen = await parseDoorByte(2);
+                    return isOpen ? this.platform.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED : this.platform.Characteristic.ContactSensorState.CONTACT_DETECTED;
+                });
             }
         })();
-        // Ice Bucket Status (Contact Sensors - "open" when full)
-        // Format: "XY" where X=fridge ice maker, Y=freezer ice maker
-        // Each nibble: 0=empty, 1=not full, 2=full, 3=full
-        // "Open" state (CONTACT_NOT_DETECTED) = bucket is full
-        // Helper to parse ice bucket nibble (half-byte)
+        // Ice Bucket Status helpers
         const parseIceBucketNibble = async (nibbleIndex) => {
             const r = await this.readErd(ERD_TYPES.ICE_MAKER_BUCKET_STATUS);
             if (!r || r.length < 2) {
-                return false; // Not full
+                return false;
             }
             try {
-                const nibble = r.charAt(nibbleIndex);
-                const status = Number.parseInt(nibble, 16);
-                const isFull = status >= 2;
-                this.debugLog(`Ice Bucket ${nibbleIndex === 0 ? 'Fridge' : 'Freezer'} status: ${nibble} (${status}) - ${isFull ? 'Full' : 'Not Full'}`);
-                return isFull;
+                const nibbleValue = nibbleIndex === 0 ? r.charAt(0) : r.charAt(1);
+                const status = Number.parseInt(nibbleValue, 16);
+                this.debugLog(`Ice bucket nibble${nibbleIndex} value: ${nibbleValue} = ${status}`);
+                return status >= 2;
             }
             catch (parseError) {
-                this.debugLog(`Ice Bucket ${nibbleIndex} parse error: ${parseError}`);
+                this.debugLog(`Ice bucket nibble${nibbleIndex} parse error: ${parseError}`);
                 return false;
             }
         };
@@ -118,9 +255,7 @@ export class SmartHQRefrigerator extends deviceBase {
             .getCharacteristic(this.platform.Characteristic.ContactSensorState)
             .onGet(async () => {
             const isFull = await parseIceBucketNibble(0);
-            return isFull
-                ? this.platform.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED // Open = full
-                : this.platform.Characteristic.ContactSensorState.CONTACT_DETECTED; // Closed = not full
+            return isFull ? this.platform.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED : this.platform.Characteristic.ContactSensorState.CONTACT_DETECTED;
         });
         // Freezer Ice Bucket (nibble 1)
         const freezerIceBucket = this.accessory.getService('Freezer Ice Bucket') ?? this.accessory.addService(this.platform.Service.ContactSensor, 'Freezer Ice Bucket', 'FreezerIceBucket');
@@ -129,155 +264,57 @@ export class SmartHQRefrigerator extends deviceBase {
             .getCharacteristic(this.platform.Characteristic.ContactSensorState)
             .onGet(async () => {
             const isFull = await parseIceBucketNibble(1);
-            return isFull
-                ? this.platform.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED // Open = full
-                : this.platform.Characteristic.ContactSensorState.CONTACT_DETECTED; // Closed = not full
+            return isFull ? this.platform.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED : this.platform.Characteristic.ContactSensorState.CONTACT_DETECTED;
         });
-        // Fridge Thermostat (with temperature sensor and target temp control)
+        // Fridge Thermostat
         const fridgeThermostat = this.accessory.getService('Fridge') ?? this.accessory.addService(this.platform.Service.Thermostat, 'Fridge', 'FridgeThermostat');
         fridgeThermostat.setCharacteristic(this.platform.Characteristic.Name, 'Fridge');
         fridgeThermostat.setCharacteristic(this.platform.Characteristic.TemperatureDisplayUnits, this.platform.Characteristic.TemperatureDisplayUnits.FAHRENHEIT);
         fridgeThermostat.setCharacteristic(this.platform.Characteristic.CurrentHeatingCoolingState, this.platform.Characteristic.CurrentHeatingCoolingState.COOL);
         fridgeThermostat.setCharacteristic(this.platform.Characteristic.TargetHeatingCoolingState, this.platform.Characteristic.TargetHeatingCoolingState.COOL);
+        fridgeThermostat
+            .getCharacteristic(this.platform.Characteristic.TargetHeatingCoolingState)
+            .setProps({ validValues: [this.platform.Characteristic.TargetHeatingCoolingState.COOL] });
         fridgeThermostat
             .getCharacteristic(this.platform.Characteristic.CurrentTemperature)
             .onGet(async () => {
-            const r = await this.readErd(ERD_TYPES.CURRENT_TEMPERATURE);
-            this.debugLog(`Raw CURRENT_TEMPERATURE ERD response: ${r}`);
-            if (!r || r === 'undefined') {
-                return 2.8; // Default to ~37°F in Celsius
-            }
-            try {
-                const temps = JSON.parse(r);
-                const fridgeTempF = temps.fridge || temps.Fridge;
-                this.debugLog(`Fridge current temp: ${fridgeTempF}°F`);
-                if (!fridgeTempF || Number.isNaN(Number(fridgeTempF))) {
-                    return 2.8;
-                }
-                return (Number(fridgeTempF) - 32) * 5 / 9;
-            }
-            catch (parseError) {
-                this.debugLog(`Fridge Temperature: JSON parse error, using default`);
-                return 2.8;
-            }
+            const temp = await this.parseTemperature('fridge');
+            return temp ?? 4.0;
         });
         fridgeThermostat
             .getCharacteristic(this.platform.Characteristic.TargetTemperature)
-            .setProps({ minValue: 0, maxValue: 7.2, minStep: 0.5 }) // 32°F to 45°F range
+            .setProps({ minValue: 0, maxValue: 7.2, minStep: 0.5 })
             .onGet(async () => {
-            const r = await this.readErd(ERD_TYPES.TEMPERATURE_SETTING);
-            if (!r || r === 'undefined') {
-                return 3.3; // Default to ~38°F
-            }
-            try {
-                const setpoints = JSON.parse(r);
-                const fridgeTargetF = setpoints.fridge || setpoints.Fridge;
-                this.debugLog(`Fridge target temp: ${fridgeTargetF}°F`);
-                if (!fridgeTargetF || Number.isNaN(Number(fridgeTargetF))) {
-                    return 3.3;
-                }
-                return (Number(fridgeTargetF) - 32) * 5 / 9;
-            }
-            catch (parseError) {
-                this.debugLog(`Fridge Target Temperature: JSON parse error, using default`);
-                return 3.3;
-            }
+            const temp = await this.parseSetpoint('fridge');
+            return temp ?? 4.0;
         })
             .onSet(async (value) => {
-            try {
-                // Convert Celsius to Fahrenheit
-                const targetF = Math.round(value * 9 / 5 + 32);
-                this.infoLog(`Setting Fridge target temperature to ${targetF}°F`);
-                // Get current freezer setting to preserve it
-                const currentSettings = await this.readErd(ERD_TYPES.TEMPERATURE_SETTING);
-                let freezerTargetF = 0; // Default
-                if (currentSettings && currentSettings !== 'undefined') {
-                    try {
-                        const setpoints = JSON.parse(currentSettings);
-                        freezerTargetF = setpoints.freezer || setpoints.Freezer || 0;
-                    }
-                    catch { }
-                }
-                // Write both fridge and freezer settings
-                const newSettings = JSON.stringify({ fridge: targetF, freezer: freezerTargetF });
-                await this.writeErd(ERD_TYPES.TEMPERATURE_SETTING, newSettings);
-            }
-            catch (error) {
-                this.warnLog?.(`Fridge set target temp error: ${error?.message ?? error}`);
-            }
+            await this.writeSetpoint('fridge', value);
         });
-        // Freezer Thermostat (with temperature sensor and target temp control)
+        // Freezer Thermostat
         const freezerThermostat = this.accessory.getService('Freezer') ?? this.accessory.addService(this.platform.Service.Thermostat, 'Freezer', 'FreezerThermostat');
         freezerThermostat.setCharacteristic(this.platform.Characteristic.Name, 'Freezer');
         freezerThermostat.setCharacteristic(this.platform.Characteristic.TemperatureDisplayUnits, this.platform.Characteristic.TemperatureDisplayUnits.FAHRENHEIT);
         freezerThermostat.setCharacteristic(this.platform.Characteristic.CurrentHeatingCoolingState, this.platform.Characteristic.CurrentHeatingCoolingState.COOL);
         freezerThermostat.setCharacteristic(this.platform.Characteristic.TargetHeatingCoolingState, this.platform.Characteristic.TargetHeatingCoolingState.COOL);
+        freezerThermostat
+            .getCharacteristic(this.platform.Characteristic.TargetHeatingCoolingState)
+            .setProps({ validValues: [this.platform.Characteristic.TargetHeatingCoolingState.COOL] });
         freezerThermostat
             .getCharacteristic(this.platform.Characteristic.CurrentTemperature)
             .onGet(async () => {
-            const r = await this.readErd(ERD_TYPES.CURRENT_TEMPERATURE);
-            this.debugLog(`Raw CURRENT_TEMPERATURE ERD response: ${r}`);
-            if (!r || r === 'undefined') {
-                return -17.8; // Default to ~0°F in Celsius
-            }
-            try {
-                const temps = JSON.parse(r);
-                const freezerTempF = temps.freezer || temps.Freezer;
-                this.debugLog(`Freezer current temp: ${freezerTempF}°F`);
-                if (!freezerTempF || Number.isNaN(Number(freezerTempF))) {
-                    return -17.8;
-                }
-                return (Number(freezerTempF) - 32) * 5 / 9;
-            }
-            catch (parseError) {
-                this.debugLog(`Freezer Temperature: JSON parse error, using default`);
-                return -17.8;
-            }
+            const temp = await this.parseTemperature('freezer');
+            return temp ?? -18.0;
         });
         freezerThermostat
             .getCharacteristic(this.platform.Characteristic.TargetTemperature)
-            .setProps({ minValue: -21, maxValue: -3.3, minStep: 0.5 }) // -6°F to 26°F range
+            .setProps({ minValue: -21, maxValue: -3.3, minStep: 0.5 })
             .onGet(async () => {
-            const r = await this.readErd(ERD_TYPES.TEMPERATURE_SETTING);
-            if (!r || r === 'undefined') {
-                return -17.8; // Default to ~0°F
-            }
-            try {
-                const setpoints = JSON.parse(r);
-                const freezerTargetF = setpoints.freezer || setpoints.Freezer;
-                this.debugLog(`Freezer target temp: ${freezerTargetF}°F`);
-                if (!freezerTargetF || Number.isNaN(Number(freezerTargetF))) {
-                    return -17.8;
-                }
-                return (Number(freezerTargetF) - 32) * 5 / 9;
-            }
-            catch (parseError) {
-                this.debugLog(`Freezer Target Temperature: JSON parse error, using default`);
-                return -17.8;
-            }
+            const temp = await this.parseSetpoint('freezer');
+            return temp ?? -18.0;
         })
             .onSet(async (value) => {
-            try {
-                // Convert Celsius to Fahrenheit
-                const targetF = Math.round(value * 9 / 5 + 32);
-                this.infoLog(`Setting Freezer target temperature to ${targetF}°F`);
-                // Get current fridge setting to preserve it
-                const currentSettings = await this.readErd(ERD_TYPES.TEMPERATURE_SETTING);
-                let fridgeTargetF = 37; // Default
-                if (currentSettings && currentSettings !== 'undefined') {
-                    try {
-                        const setpoints = JSON.parse(currentSettings);
-                        fridgeTargetF = setpoints.fridge || setpoints.Fridge || 37;
-                    }
-                    catch { }
-                }
-                // Write both fridge and freezer settings
-                const newSettings = JSON.stringify({ fridge: fridgeTargetF, freezer: targetF });
-                await this.writeErd(ERD_TYPES.TEMPERATURE_SETTING, newSettings);
-            }
-            catch (error) {
-                this.warnLog?.(`Freezer set target temp error: ${error?.message ?? error}`);
-            }
+            await this.writeSetpoint('freezer', value);
         });
         // Air Filter Maintenance
         const filterService = this.accessory.getService('Air Filter') ?? this.accessory.addService(this.platform.Service.FilterMaintenance, 'Air Filter', 'AirFilter');
@@ -293,7 +330,7 @@ export class SmartHQRefrigerator extends deviceBase {
                 ? this.platform.Characteristic.FilterChangeIndication.CHANGE_FILTER
                 : this.platform.Characteristic.FilterChangeIndication.FILTER_OK;
         });
-        // Ice Maker Control (Switch)
+        // Ice Maker Control
         const iceMakerService = this.accessory.getService('Ice Maker') ?? this.accessory.addService(this.platform.Service.Switch, 'Ice Maker', 'IceMaker');
         iceMakerService.setCharacteristic(this.platform.Characteristic.Name, 'Ice Maker');
         iceMakerService
@@ -329,16 +366,207 @@ export class SmartHQRefrigerator extends deviceBase {
             .onSet(async (value) => {
             await this.writeErd(ERD_TYPES.TURBO_FREEZE_STATUS, value);
         });
-        // this is subject we use to track when we need to POST changes to the SmartHQ API
-        this.SensorUpdateInProgress = false;
-        // Retrieve initial values and updateHomekit
-        // this.refreshStatus()
-        // Start an update interval
-        interval(this.deviceRefreshRate * 10000)
-            .pipe(skipWhile(() => this.SensorUpdateInProgress))
-            .subscribe(async () => {
-            // await this.refreshStatus()
-        });
+    }
+    /**
+     * Shared helper: Parse temperature from ERD (works for both HAP and Matter)
+     */
+    async parseTemperature(compartment) {
+        const r = await this.readErd(ERD_TYPES.CURRENT_TEMPERATURE);
+        this.debugLog(`Raw CURRENT_TEMPERATURE ERD response: ${r}`);
+        if (!r || r === 'undefined') {
+            return undefined;
+        }
+        try {
+            const parsed = JSON.parse(r);
+            if (parsed[compartment] !== undefined) {
+                const tempCelsius = Number(parsed[compartment]);
+                this.debugLog(`${compartment} temperature: ${tempCelsius}°C`);
+                return tempCelsius;
+            }
+        }
+        catch (parseError) {
+            this.debugLog(`Temperature parse error: ${parseError}`);
+        }
+        return undefined;
+    }
+    /**
+     * Shared helper: Parse setpoint from ERD
+     */
+    async parseSetpoint(compartment) {
+        const r = await this.readErd(ERD_TYPES.TEMPERATURE_SETTING);
+        if (!r || r === 'undefined') {
+            return undefined;
+        }
+        try {
+            const parsed = JSON.parse(r);
+            if (parsed[compartment] !== undefined) {
+                const tempCelsius = Number(parsed[compartment]);
+                this.debugLog(`${compartment} setpoint: ${tempCelsius}°C`);
+                return tempCelsius;
+            }
+        }
+        catch (parseError) {
+            this.debugLog(`Setpoint parse error: ${parseError}`);
+        }
+        return undefined;
+    }
+    /**
+     * Shared helper: Write setpoint to ERD
+     */
+    async writeSetpoint(compartment, temperature) {
+        try {
+            const value = Math.round(temperature).toString();
+            const erdData = JSON.stringify({ [compartment]: value });
+            await this.writeErd(ERD_TYPES.TEMPERATURE_SETTING, erdData);
+            await this.successLog(`Set ${compartment} temperature to ${value}°C`);
+        }
+        catch (error) {
+            await this.errorLog(`Failed to write ${compartment} setpoint: ${error?.message ?? error}`);
+        }
+    }
+    /**
+     * Handle Matter setpoint change
+     */
+    async handleMatterSetpointChange(request) {
+        try {
+            const amount = request.amount;
+            const currentSetpoint = await this.parseSetpoint('fridge') ?? 4;
+            const newSetpoint = currentSetpoint + (amount / 10);
+            await this.infoLog(`Matter setpoint adjust: ${amount * 0.1}°C (${currentSetpoint}°C -> ${newSetpoint}°C)`);
+            await this.writeSetpoint('fridge', newSetpoint);
+        }
+        catch (error) {
+            await this.errorLog(`Failed to adjust Matter setpoint: ${error?.message ?? error}`);
+        }
+    }
+    /**
+     * Handle Matter mode change (Normal, Rapid Cool, Rapid Freeze)
+     */
+    async handleMatterModeChange(request) {
+        try {
+            const newMode = request.newMode;
+            await this.infoLog(`Matter mode change to: ${newMode === 0 ? 'Normal' : newMode === 1 ? 'Rapid Cool' : 'Rapid Freeze'}`);
+            // Map Matter modes to SmartHQ ERD codes
+            if (newMode === 1) {
+                // Rapid Cool - enable Turbo Cool
+                await this.writeErd(ERD_TYPES.TURBO_COOL_STATUS, true);
+                await this.writeErd(ERD_TYPES.TURBO_FREEZE_STATUS, false);
+            }
+            else if (newMode === 2) {
+                // Rapid Freeze - enable Turbo Freeze
+                await this.writeErd(ERD_TYPES.TURBO_COOL_STATUS, false);
+                await this.writeErd(ERD_TYPES.TURBO_FREEZE_STATUS, true);
+            }
+            else {
+                // Normal - disable both
+                await this.writeErd(ERD_TYPES.TURBO_COOL_STATUS, false);
+                await this.writeErd(ERD_TYPES.TURBO_FREEZE_STATUS, false);
+            }
+            // Update the mode cluster
+            if (this.matterUuid) {
+                const matterAPI = this.api.matter;
+                await matterAPI.updateAccessoryState(this.matterUuid, 'refrigeratorAndTemperatureControlledCabinetMode', { mode: newMode });
+            }
+        }
+        catch (error) {
+            await this.errorLog(`Failed to change Matter mode: ${error?.message ?? error}`);
+        }
+    }
+    /**
+     * Refresh device status - update both HAP and Matter states
+     */
+    async refreshDeviceStatus() {
+        try {
+            this.SensorUpdateInProgress = true;
+            // Get temperatures
+            const fridgeTemp = await this.parseTemperature('fridge');
+            const freezerTemp = await this.parseTemperature('freezer');
+            // Get setpoints
+            const fridgeSetpoint = await this.parseSetpoint('fridge');
+            const freezerSetpoint = await this.parseSetpoint('freezer');
+            // Get door status for alarm cluster
+            const doorStatus = await this.readErd(ERD_TYPES.DOOR_STATUS);
+            // Get ice maker status
+            const iceMakerStatus = await this.readErd(ERD_TYPES.ICE_MAKER_CONTROL);
+            // Get turbo cool/freeze status for mode cluster
+            const turboCoolStatus = await this.readErd(ERD_TYPES.TURBO_COOL_STATUS);
+            const turboFreezeStatus = await this.readErd(ERD_TYPES.TURBO_FREEZE_STATUS);
+            // Get filter status for resource monitoring
+            const filterStatus = await this.readErd(ERD_TYPES.AIR_FILTER_STATUS);
+            // Update Matter state if using Matter
+            if (this.useMatterOverride && this.matterUuid) {
+                const matterAPI = this.api.matter;
+                // Update fridge values
+                if (fridgeTemp !== undefined) {
+                    await matterAPI.updateAccessoryState(this.matterUuid, matterAPI.clusterNames.Thermostat, { localTemperature: Math.round(fridgeTemp * 100) });
+                    await matterAPI.updateAccessoryState(this.matterUuid, 'temperatureMeasurement', { measuredValue: Math.round(fridgeTemp * 100) });
+                }
+                // Update fridge setpoint
+                if (fridgeSetpoint !== undefined) {
+                    await matterAPI.updateAccessoryState(this.matterUuid, matterAPI.clusterNames.Thermostat, { occupiedCoolingSetpoint: Math.round(fridgeSetpoint * 100) });
+                }
+                // Update freezer values
+                if (freezerTemp !== undefined) {
+                    await matterAPI.updateAccessoryState(this.matterUuid, matterAPI.clusterNames.Thermostat, { localTemperature: Math.round(freezerTemp * 100) });
+                }
+                // Update freezer setpoint
+                if (freezerSetpoint !== undefined) {
+                    await matterAPI.updateAccessoryState(this.matterUuid, matterAPI.clusterNames.Thermostat, { occupiedCoolingSetpoint: Math.round(freezerSetpoint * 100) });
+                }
+                // Update refrigerator mode cluster based on turbo status
+                let currentMode = 0; // Normal
+                if (turboCoolStatus && Number.parseInt(turboCoolStatus) !== 0) {
+                    currentMode = 1; // Rapid Cool
+                }
+                else if (turboFreezeStatus && Number.parseInt(turboFreezeStatus) !== 0) {
+                    currentMode = 2; // Rapid Freeze
+                }
+                await matterAPI.updateAccessoryState(this.matterUuid, 'refrigeratorAndTemperatureControlledCabinetMode', { mode: currentMode });
+                // Update refrigerator alarm cluster
+                let alarmState = 0;
+                if (doorStatus) {
+                    // Check if any door is open (non-zero value)
+                    const byte0 = doorStatus.substring(0, 2);
+                    const byte1 = doorStatus.substring(2, 4);
+                    const byte2 = doorStatus.substring(4, 6);
+                    if (byte0 !== '00' || byte1 !== '00' || byte2 !== '00') {
+                        alarmState |= 1; // Set door open alarm bit
+                    }
+                }
+                await matterAPI.updateAccessoryState(this.matterUuid, 'refrigeratorAlarm', { state: alarmState });
+                // Update fridge compartment endpoint
+                const fridgeEndpointUuid = matterAPI.uuid.generate(`${this.device.applianceId}-fridge`);
+                if (fridgeTemp !== undefined) {
+                    await matterAPI.updateAccessoryState(fridgeEndpointUuid, 'temperatureMeasurement', { measuredValue: Math.round(fridgeTemp * 100) });
+                }
+                // Update fridge ice maker boolean state
+                if (iceMakerStatus) {
+                    await matterAPI.updateAccessoryState(fridgeEndpointUuid, 'booleanState', { stateValue: Number.parseInt(iceMakerStatus) !== 0 });
+                }
+                // Update fridge filter resource monitoring
+                if (filterStatus) {
+                    const needsReplacement = Number.parseInt(filterStatus) === 1;
+                    await matterAPI.updateAccessoryState(fridgeEndpointUuid, 'resourceMonitoring', {
+                        condition: needsReplacement ? 0 : 100,
+                        changeIndication: needsReplacement ? 2 : 0, // 2=Critical, 0=OK
+                    });
+                }
+                // Update freezer compartment endpoint
+                const freezerEndpointUuid = matterAPI.uuid.generate(`${this.device.applianceId}-freezer`);
+                if (freezerTemp !== undefined) {
+                    await matterAPI.updateAccessoryState(freezerEndpointUuid, 'temperatureMeasurement', { measuredValue: Math.round(freezerTemp * 100) });
+                }
+                // Update freezer turbo freeze boolean state
+                if (turboFreezeStatus) {
+                    await matterAPI.updateAccessoryState(freezerEndpointUuid, 'booleanState', { stateValue: Number.parseInt(turboFreezeStatus) !== 0 });
+                }
+            }
+            this.SensorUpdateInProgress = false;
+        }
+        catch (error) {
+            this.SensorUpdateInProgress = false;
+            await this.errorLog(`Failed to refresh device status: ${error?.message ?? error}`);
+        }
     }
 }
 //# sourceMappingURL=refrigerator.js.map