matterbridge-lg-thinq-plugin 0.1.0

package/src/platform/thinq/thinqAirConditionerFilterResetCommandHandler.ts

@@ -0,0 +1,96 @@
+import { MatterbridgeEndpoint } from 'matterbridge';
+import { AnsiLogger } from 'matterbridge/logger';
+
+import type { ThinqAirConditionerDevice } from '../../core/domain/entities/ThinqDevice.js';
+import type { AirConditionerCapabilities } from '../../core/domain/value-objects/AirConditionerCapabilities.js';
+import { ThinqFilterState } from '../../core/domain/value-objects/ThinqFilterState.js';
+import type { ThinqAcFilterControlConfig } from '../../model/LgThinqPluginPlatformConfig.js';
+import type { ThinqApiClient } from '../../services/thinq/thinqApiClient.js';
+
+const KEY_USE_TIME = 'airState.filterMngState.useTime';
+const KEY_REMAIN_TIME = 'airState.filterMngState.remainTime';
+const KEY_MAX_TIME = 'airState.filterMngState.maxTime';
+const KEY_CHANGE_DATE = 'airState.filterMngState.changeDate';
+
+/**
+ * Builds the `filterMngStateCtrl` `Set` payload for a filter-counter reset, scoped strictly to the
+ * field names already proven present in this device's own live `Get` response — echoes `maxTime`
+ * back unchanged (never mutates the device's rated filter life) and resets `useTime`/`remainTime`/
+ * `changeDate` to their reset-state values.
+ */
+export function resolveFilterResetPayload(
+	filterState: ThinqFilterState,
+	now: Date = new Date(),
+): Record<string, unknown> {
+	return {
+		[KEY_USE_TIME]: 0,
+		[KEY_REMAIN_TIME]: filterState.ratedMaxTimeHours,
+		[KEY_MAX_TIME]: filterState.ratedMaxTimeHours,
+		[KEY_CHANGE_DATE]: formatChangeDate(now),
+	};
+}
+
+function formatChangeDate(date: Date): number {
+	const year = date.getUTCFullYear();
+	const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+	const day = String(date.getUTCDate()).padStart(2, '0');
+	return Number(`${year}${month}${day}`);
+}
+
+/**
+ * Registers the Matter `HepaFilterMonitoring.resetCondition()` command handler. No-ops entirely when
+ * `supportsFilterMonitoring` is false (the cluster is never created on the endpoint in that case).
+ * Never writes `condition`/`changeIndication`/`lastChangedTime` itself — matterbridge's own
+ * `MatterbridgeHepaFilterMonitoringServer.resetCondition()` does that automatically, but only after
+ * this handler resolves without throwing.
+ */
+export function registerFilterResetCommandHandler(
+	airConditioner: MatterbridgeEndpoint,
+	device: ThinqAirConditionerDevice,
+	apiClient: ThinqApiClient,
+	logger: AnsiLogger,
+	capabilities: AirConditionerCapabilities,
+	filterResetControl: ThinqAcFilterControlConfig,
+): void {
+	if (!capabilities.supportsFilterMonitoring) {
+		return;
+	}
+
+	airConditioner.addCommandHandler('resetCondition', async () => {
+		if (!filterResetControl.allowFilterReset) {
+			logger.warn(`ThinQ AirConditioner filter reset is disabled by configuration (deviceId=${device.id})`);
+			throw new Error('ThinQ AirConditioner filter reset is disabled by configuration.');
+		}
+
+		let filterState: ThinqFilterState | undefined;
+		try {
+			filterState = ThinqFilterState.fromRaw(await apiClient.getFilterState(device.id));
+		} catch (error) {
+			logger.error(
+				`ThinQ AirConditioner filter reset failed to read current filter state: ${error instanceof Error ? error.message : String(error)} (deviceId=${device.id})`,
+			);
+			throw error;
+		}
+
+		if (!filterState) {
+			logger.warn(
+				`ThinQ AirConditioner filter reset: no current filter data available, refusing to reset (deviceId=${device.id})`,
+			);
+			throw new Error('ThinQ AirConditioner filter reset: no current filter data available for this device.');
+		}
+
+		try {
+			await apiClient.sendCommand(device.id, {
+				ctrlKey: 'filterMngStateCtrl',
+				command: 'Set',
+				dataSetList: resolveFilterResetPayload(filterState),
+			});
+			logger.info(`ThinQ AirConditioner filter reset succeeded (deviceId=${device.id})`);
+		} catch (error) {
+			logger.error(
+				`ThinQ AirConditioner filter reset command failed: ${error instanceof Error ? error.message : String(error)} (deviceId=${device.id})`,
+			);
+			throw error;
+		}
+	});
+}

package/src/platform/thinq/thinqAirConditionerFilterStateSync.ts

@@ -0,0 +1,42 @@
+import { MatterbridgeEndpoint } from 'matterbridge';
+import { AnsiLogger } from 'matterbridge/logger';
+import { HepaFilterMonitoring, ResourceMonitoring } from 'matterbridge/matter/clusters';
+
+import type { ThinqFilterState } from '../../core/domain/value-objects/ThinqFilterState.js';
+
+const FILTER_WARNING_THRESHOLD_PERCENT = 10;
+
+/** 3-way threshold mapping from remaining filter life percent to a Matter `ChangeIndication`. */
+export function resolveFilterChangeIndication(remainingPercent: number): ResourceMonitoring.ChangeIndication {
+	if (remainingPercent <= 0) {
+		return ResourceMonitoring.ChangeIndication.Critical;
+	}
+	if (remainingPercent <= FILTER_WARNING_THRESHOLD_PERCENT) {
+		return ResourceMonitoring.ChangeIndication.Warning;
+	}
+	return ResourceMonitoring.ChangeIndication.Ok;
+}
+
+/**
+ * Pushes filter-life state to the AC endpoint's `HepaFilterMonitoring` cluster. When `filterState` is
+ * `undefined` (e.g. the device has no filter sensor), writes nothing and leaves the cluster's
+ * construction-time defaults (`condition=100, changeIndication=Ok`) in place.
+ */
+export async function applyThinqFilterStateToAirConditioner(
+	airConditioner: MatterbridgeEndpoint,
+	filterState: ThinqFilterState | undefined,
+	logger: AnsiLogger,
+): Promise<void> {
+	if (!filterState) {
+		logger.debug('ThinQ filter state: no data, skipping HepaFilterMonitoring update.');
+		return;
+	}
+
+	await airConditioner.updateAttribute(HepaFilterMonitoring.id, 'condition', filterState.remainingPercent, logger);
+	await airConditioner.updateAttribute(
+		HepaFilterMonitoring.id,
+		'changeIndication',
+		resolveFilterChangeIndication(filterState.remainingPercent),
+		logger,
+	);
+}

package/src/platform/thinq/thinqAirConditionerStateSync.ts

@@ -0,0 +1,343 @@
+import { MatterbridgeEndpoint } from 'matterbridge';
+import { AnsiLogger } from 'matterbridge/logger';
+import {
+	AirQuality,
+	ElectricalPowerMeasurement,
+	FanControl,
+	OnOff,
+	Pm10ConcentrationMeasurement,
+	Pm25ConcentrationMeasurement,
+	RelativeHumidityMeasurement,
+	TemperatureMeasurement,
+	Thermostat,
+} from 'matterbridge/matter/clusters';
+
+import type { AirConditionerCapabilities } from '../../core/domain/value-objects/AirConditionerCapabilities.js';
+import type { ThinqSnapshot } from '../../core/domain/value-objects/ThinqSnapshot.js';
+import {
+	THINQ_FAN_SPEED_AUTO,
+	THINQ_FAN_SPEED_LOW,
+	THINQ_FAN_SPEED_MEDIUM,
+} from './thinqAirConditionerCommandHandlers.js';
+import { mapWindStrengthToFanMode, mapWindStrengthToFixedFanMode } from './thinqDeviceConfigurator.js';
+
+/** LG `airState.opMode` values (`homebridge-lg-thinq/src/devices/AirConditioner.ts`). */
+const THINQ_OP_MODE_COOL = 0;
+const THINQ_OP_MODE_DRY = 1;
+const THINQ_OP_MODE_FAN = 2;
+const THINQ_OP_MODE_HEAT = 4;
+const THINQ_OP_MODE_AIR_CLEAN = 5;
+const THINQ_OP_MODE_AUTO = 6;
+
+const WIND_STRENGTH_LOW_PERCENT = 20;
+const WIND_STRENGTH_MEDIUM_PERCENT = 50;
+const WIND_STRENGTH_HIGH_PERCENT = 90;
+
+const KEY_OPERATION = 'airState.operation';
+const KEY_OP_MODE = 'airState.opMode';
+const KEY_TEMP_CURRENT = 'airState.tempState.current';
+const KEY_TEMP_TARGET = 'airState.tempState.target';
+const KEY_WIND_STRENGTH = 'airState.windStrength';
+const KEY_SWING_VERTICAL = 'airState.wDir.vStep';
+const KEY_SWING_HORIZONTAL = 'airState.wDir.hStep';
+
+/** Maps a ThinQ `airState.windStrength` value to a Matter `FanControl.percentCurrent` (Auto has no percent equivalent). */
+export function mapWindStrengthToPercent(windStrength: number | undefined): number | undefined {
+	if (windStrength === undefined || windStrength === THINQ_FAN_SPEED_AUTO) {
+		return undefined;
+	}
+	if (windStrength <= THINQ_FAN_SPEED_LOW) {
+		return WIND_STRENGTH_LOW_PERCENT;
+	}
+	if (windStrength <= THINQ_FAN_SPEED_MEDIUM) {
+		return WIND_STRENGTH_MEDIUM_PERCENT;
+	}
+	return WIND_STRENGTH_HIGH_PERCENT;
+}
+
+/**
+ * Maps ThinQ power-state + `airState.opMode` to a Matter `Thermostat.SystemMode`.
+ * Apple Home's Thermostat UI only exposes Off/Heat/Cool/Auto, so Dry and Fan-only opModes
+ * (which have no equivalent Apple-visible slot) collapse into Cool.
+ */
+export function mapOperationModeToSystemMode(
+	operationMode: number | undefined,
+	isPowerOn: boolean,
+	capabilities: AirConditionerCapabilities,
+): Thermostat.SystemMode {
+	if (!isPowerOn) {
+		return Thermostat.SystemMode.Off;
+	}
+
+	switch (operationMode) {
+		case THINQ_OP_MODE_AUTO:
+			return capabilities.supportsHeat ? Thermostat.SystemMode.Auto : Thermostat.SystemMode.Cool;
+		case THINQ_OP_MODE_COOL:
+			return Thermostat.SystemMode.Cool;
+		case THINQ_OP_MODE_HEAT:
+			return capabilities.supportsHeat ? Thermostat.SystemMode.Heat : Thermostat.SystemMode.Cool;
+		case THINQ_OP_MODE_FAN:
+			return Thermostat.SystemMode.Cool;
+		case THINQ_OP_MODE_DRY:
+			return Thermostat.SystemMode.Cool;
+		case THINQ_OP_MODE_AIR_CLEAN:
+		default:
+			return capabilities.supportsHeat ? Thermostat.SystemMode.Auto : Thermostat.SystemMode.Cool;
+	}
+}
+
+/** Resolves systemMode update from a snapshot, returning undefined if the write should be skipped. */
+function resolveSystemModeUpdate(
+	airConditioner: MatterbridgeEndpoint,
+	snapshot: ThinqSnapshot,
+	capabilities: AirConditionerCapabilities,
+): Thermostat.SystemMode | undefined {
+	if (!snapshot.has(KEY_OPERATION)) {
+		if (!snapshot.has(KEY_OP_MODE)) {
+			return undefined;
+		}
+		// operation absent, opMode present: derive power from current OnOff attribute
+		const currentPowerOn = (airConditioner.getAttribute(OnOff.id, 'onOff') as boolean | undefined) === true;
+		if (!currentPowerOn) {
+			return undefined;
+		}
+		return mapOperationModeToSystemMode(snapshot.operationMode, true, capabilities);
+	}
+
+	// operation present
+	const isPowerOn = snapshot.isPowerOn;
+	if (isPowerOn && !snapshot.has(KEY_OP_MODE)) {
+		// operation present and 1, opMode absent: skip systemMode
+		return undefined;
+	}
+
+	return mapOperationModeToSystemMode(snapshot.operationMode, isPowerOn, capabilities);
+}
+
+/**
+ * True when the AC is known to be off: the snapshot's `airState.operation` if present, otherwise the endpoint's
+ * current OnOff attribute (unknown/undefined is treated as NOT off).
+ */
+function isKnownOff(airConditioner: MatterbridgeEndpoint, snapshot: ThinqSnapshot): boolean {
+	if (snapshot.has(KEY_OPERATION)) {
+		return !snapshot.isPowerOn;
+	}
+	return (airConditioner.getAttribute(OnOff.id, 'onOff') as boolean | undefined) === false;
+}
+
+/** Resolves rock setting from a snapshot, returning undefined if neither swing axis key is present. */
+function resolveRockSetting(
+	airConditioner: MatterbridgeEndpoint,
+	snapshot: ThinqSnapshot,
+): { rockLeftRight: boolean; rockUpDown: boolean; rockRound: boolean } | undefined {
+	const hasVertical = snapshot.has(KEY_SWING_VERTICAL);
+	const hasHorizontal = snapshot.has(KEY_SWING_HORIZONTAL);
+
+	if (!hasVertical && !hasHorizontal) {
+		return undefined;
+	}
+
+	let verticalOn = snapshot.isVerticalSwingOn;
+	let horizontalOn = snapshot.isHorizontalSwingOn;
+
+	// Fallback to current attribute if only one axis is present
+	if (!hasVertical) {
+		const currentRockSetting = airConditioner.getAttribute(FanControl.id, 'rockSetting') as
+			{ rockUpDown?: boolean } | undefined;
+		verticalOn = currentRockSetting?.rockUpDown ?? false;
+	}
+
+	if (!hasHorizontal) {
+		const currentRockSetting = airConditioner.getAttribute(FanControl.id, 'rockSetting') as
+			{ rockLeftRight?: boolean } | undefined;
+		horizontalOn = currentRockSetting?.rockLeftRight ?? false;
+	}
+
+	return {
+		rockLeftRight: horizontalOn,
+		rockUpDown: verticalOn,
+		rockRound: verticalOn && horizontalOn,
+	};
+}
+
+/**
+ * Pushes a freshly polled ThinQ snapshot onto the Matter `AirConditioner` endpoint's attributes
+ * (device → Apple Home). Uses `updateAttribute` (idempotent) to avoid redundant attribute-report churn.
+ */
+export async function applyThinqSnapshotToAirConditioner(
+	airConditioner: MatterbridgeEndpoint,
+	snapshot: ThinqSnapshot,
+	capabilities: AirConditionerCapabilities,
+	logger: AnsiLogger,
+): Promise<void> {
+	const deviceId = airConditioner.serialNumber ?? airConditioner.uniqueId ?? 'unknown';
+	const hasPower = snapshot.has(KEY_OPERATION);
+	const systemModeUpdate = resolveSystemModeUpdate(airConditioner, snapshot, capabilities);
+	const rockSetting =
+		capabilities.supportsFanSpeedControl && capabilities.supportsSwingMode
+			? resolveRockSetting(airConditioner, snapshot)
+			: undefined;
+
+	const attributesToPush: string[] = [];
+	const attributesToSkip: string[] = [];
+
+	if (hasPower) {
+		attributesToPush.push('power');
+	} else {
+		attributesToSkip.push('power');
+	}
+
+	if (systemModeUpdate !== undefined) {
+		attributesToPush.push('systemMode');
+	} else {
+		attributesToSkip.push('systemMode');
+	}
+
+	if (snapshot.currentTemperatureCelsius !== undefined) {
+		attributesToPush.push('currentTemp');
+	} else if (snapshot.has(KEY_TEMP_CURRENT)) {
+		attributesToSkip.push('currentTemp');
+	}
+
+	if (snapshot.targetTemperatureCelsius !== undefined) {
+		attributesToPush.push('targetTemp');
+	} else if (snapshot.has(KEY_TEMP_TARGET)) {
+		attributesToSkip.push('targetTemp');
+	}
+
+	if (snapshot.has(KEY_WIND_STRENGTH)) {
+		attributesToPush.push('fanSpeed');
+	} else if (capabilities.supportsFanSpeedControl) {
+		attributesToSkip.push('fanSpeed');
+	}
+
+	logger.debug(
+		`applyThinqSnapshotToAirConditioner: entry for deviceId=${deviceId}, pushing ${attributesToPush.length} attributes: ${attributesToPush.join(', ')}`,
+	);
+
+	if (attributesToSkip.length > 0) {
+		logger.debug(`applyThinqSnapshotToAirConditioner: skipped (source key absent): ${attributesToSkip.join(', ')}`);
+	}
+
+	if (hasPower) {
+		await airConditioner.updateAttribute(OnOff.id, 'onOff', snapshot.isPowerOn, logger);
+	}
+
+	const currentTemperatureCelsius = snapshot.currentTemperatureCelsius;
+	if (currentTemperatureCelsius !== undefined) {
+		await airConditioner.updateAttribute(
+			TemperatureMeasurement.id,
+			'measuredValue',
+			currentTemperatureCelsius * 100,
+			logger,
+		);
+		await airConditioner.updateAttribute(Thermostat.id, 'localTemperature', currentTemperatureCelsius * 100, logger);
+	}
+
+	const targetTemperatureCelsius = snapshot.targetTemperatureCelsius;
+	if (targetTemperatureCelsius !== undefined) {
+		await airConditioner.updateAttribute(
+			Thermostat.id,
+			'occupiedCoolingSetpoint',
+			targetTemperatureCelsius * 100,
+			logger,
+		);
+		if (capabilities.supportsHeat) {
+			await airConditioner.updateAttribute(
+				Thermostat.id,
+				'occupiedHeatingSetpoint',
+				targetTemperatureCelsius * 100,
+				logger,
+			);
+		}
+	}
+
+	if (systemModeUpdate !== undefined) {
+		await airConditioner.updateAttribute(Thermostat.id, 'systemMode', systemModeUpdate, logger);
+	}
+
+	if (snapshot.has(KEY_WIND_STRENGTH)) {
+		if (capabilities.supportsFanSpeedControl) {
+			await airConditioner.updateAttribute(
+				FanControl.id,
+				'fanMode',
+				mapWindStrengthToFanMode(snapshot.windStrength),
+				logger,
+			);
+
+			const percentCurrent = mapWindStrengthToPercent(snapshot.windStrength);
+			if (percentCurrent !== undefined) {
+				await airConditioner.updateAttribute(FanControl.id, 'percentCurrent', percentCurrent, logger);
+			}
+		} else {
+			await airConditioner.updateAttribute(
+				FanControl.id,
+				'fanMode',
+				mapWindStrengthToFixedFanMode(snapshot.windStrength),
+				logger,
+			);
+		}
+	}
+
+	if (capabilities.supportsFanSpeedControl && capabilities.supportsSwingMode && rockSetting !== undefined) {
+		await airConditioner.updateAttribute(FanControl.id, 'rockSetting', rockSetting, logger);
+	}
+
+	if (capabilities.supportsHumiditySensor) {
+		const humidityPercent = snapshot.humidityPercent;
+		if (humidityPercent !== undefined) {
+			const humiditySensorChild = airConditioner.getChildEndpointById('HumiditySensor');
+			if (humiditySensorChild) {
+				await humiditySensorChild.updateAttribute(
+					RelativeHumidityMeasurement.id,
+					'measuredValue',
+					humidityPercent * 100,
+					logger,
+				);
+			}
+		}
+	}
+
+	if (capabilities.supportsAirQualitySensor) {
+		const airQualitySensorChild = airConditioner.getChildEndpointById('AirQualitySensor');
+		if (airQualitySensorChild) {
+			const airQualityOverall = snapshot.airQualityOverall;
+			if (airQualityOverall !== undefined) {
+				await airQualitySensorChild.updateAttribute(AirQuality.id, 'airQuality', airQualityOverall, logger);
+			}
+
+			const pm25Value = snapshot.pm25;
+			if (pm25Value !== undefined) {
+				await airQualitySensorChild.updateAttribute(
+					Pm25ConcentrationMeasurement.id,
+					'measuredValue',
+					pm25Value,
+					logger,
+				);
+			}
+
+			const pm10Value = snapshot.pm10;
+			if (pm10Value !== undefined) {
+				await airQualitySensorChild.updateAttribute(
+					Pm10ConcentrationMeasurement.id,
+					'measuredValue',
+					pm10Value,
+					logger,
+				);
+			}
+		}
+	}
+
+	if (capabilities.supportsEnergyMonitoring) {
+		// LG reports a floor raw value (~50 W) while the AC is off; never show that as consumption.
+		const watts = isKnownOff(airConditioner, snapshot) ? 0 : snapshot.powerConsumptionWatts;
+		if (watts !== undefined) {
+			await airConditioner.updateAttribute(
+				ElectricalPowerMeasurement.id,
+				'activePower',
+				Math.round(watts * 1000),
+				logger,
+			);
+		}
+	}
+}

package/src/platform/thinq/thinqDeviceConfigReconciler.ts

@@ -0,0 +1,42 @@
+import { isAirConditionerDevice, isWasherDevice, type ThinqDevice } from '../../core/domain/entities/ThinqDevice.js';
+import type { ThinqDeviceConfigEntry } from '../../model/LgThinqPluginPlatformConfig.js';
+
+/**
+ * Reconciles the config device entries with discovered devices by auto-populating/backfilling
+ * the `deviceType` field on all entries (required for schema visibility gating) and creating
+ * minimal entries for newly discovered devices.
+ *
+ * Mutates `configDevices` in place. Returns `true` iff at least one push/backfill happened.
+ * Never throws — defensively skips any device/entry that cannot be classified.
+ */
+export function reconcileThinqDeviceConfigEntries(
+	configDevices: ThinqDeviceConfigEntry[],
+	discoveredDevices: ThinqDevice[],
+): boolean {
+	let changed = false;
+
+	for (const discovered of discoveredDevices) {
+		// Defensively determine the device type; skip if not recognizable.
+		let deviceType: 'AC' | 'WASHER' | undefined;
+		if (isAirConditionerDevice(discovered)) {
+			deviceType = 'AC';
+		} else if (isWasherDevice(discovered)) {
+			deviceType = 'WASHER';
+		} else {
+			continue; // Skip devices that match neither guard.
+		}
+
+		const existingEntry = configDevices.find((d) => d.deviceId === discovered.id);
+		if (!existingEntry) {
+			// New device: create a minimal entry with just deviceId and deviceType.
+			configDevices.push({ deviceId: discovered.id, deviceType });
+			changed = true;
+		} else if (existingEntry.deviceType !== deviceType) {
+			// Existing entry with mismatched or missing deviceType: backfill/correct it.
+			existingEntry.deviceType = deviceType;
+			changed = true;
+		}
+	}
+
+	return changed;
+}

package/src/platform/thinq/thinqDeviceConfigurator.test.ts

@@ -0,0 +1,90 @@
+import { FanControl } from 'matterbridge/matter/clusters';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { mapWindStrengthToFanMode, mapWindStrengthToFixedFanMode } from './thinqDeviceConfigurator.js';
+
+describe('thinqDeviceConfigurator', () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	describe('mapWindStrengthToFanMode', () => {
+		it('should map undefined to Auto mode', () => {
+			const mode = mapWindStrengthToFanMode(undefined);
+			expect(mode).toBe(FanControl.FanMode.Auto);
+		});
+
+		it('should map windStrength 8 (AUTO) to Auto mode', () => {
+			const mode = mapWindStrengthToFanMode(8);
+			expect(mode).toBe(FanControl.FanMode.Auto);
+		});
+
+		it('should map windStrength <= 2 to Low mode', () => {
+			expect(mapWindStrengthToFanMode(0)).toBe(FanControl.FanMode.Low);
+			expect(mapWindStrengthToFanMode(1)).toBe(FanControl.FanMode.Low);
+			expect(mapWindStrengthToFanMode(2)).toBe(FanControl.FanMode.Low);
+		});
+
+		it('should map windStrength > 2 and <= 4 to Medium mode', () => {
+			expect(mapWindStrengthToFanMode(3)).toBe(FanControl.FanMode.Medium);
+			expect(mapWindStrengthToFanMode(4)).toBe(FanControl.FanMode.Medium);
+		});
+
+		it('should map windStrength > 4 to High mode', () => {
+			expect(mapWindStrengthToFanMode(5)).toBe(FanControl.FanMode.High);
+			expect(mapWindStrengthToFanMode(6)).toBe(FanControl.FanMode.High);
+			expect(mapWindStrengthToFanMode(7)).toBe(FanControl.FanMode.High);
+			expect(mapWindStrengthToFanMode(9)).toBe(FanControl.FanMode.High);
+		});
+
+		it('should handle edge case windStrength = 2.5', () => {
+			const mode = mapWindStrengthToFanMode(2.5);
+			expect(mode).toBe(FanControl.FanMode.Medium);
+		});
+
+		it('should handle edge case windStrength = 4.1', () => {
+			const mode = mapWindStrengthToFanMode(4.1);
+			expect(mode).toBe(FanControl.FanMode.High);
+		});
+
+		it('should handle very high windStrength values', () => {
+			const mode = mapWindStrengthToFanMode(100);
+			expect(mode).toBe(FanControl.FanMode.High);
+		});
+
+		it('should handle negative windStrength', () => {
+			const mode = mapWindStrengthToFanMode(-1);
+			expect(mode).toBe(FanControl.FanMode.Low);
+		});
+	});
+
+	describe('mapWindStrengthToFixedFanMode', () => {
+		it('should map undefined to Off mode', () => {
+			const mode = mapWindStrengthToFixedFanMode(undefined);
+			expect(mode).toBe(FanControl.FanMode.Off);
+		});
+
+		it('should map any defined windStrength to High mode', () => {
+			expect(mapWindStrengthToFixedFanMode(0)).toBe(FanControl.FanMode.High);
+			expect(mapWindStrengthToFixedFanMode(1)).toBe(FanControl.FanMode.High);
+			expect(mapWindStrengthToFixedFanMode(2)).toBe(FanControl.FanMode.High);
+			expect(mapWindStrengthToFixedFanMode(5)).toBe(FanControl.FanMode.High);
+			expect(mapWindStrengthToFixedFanMode(8)).toBe(FanControl.FanMode.High);
+			expect(mapWindStrengthToFixedFanMode(100)).toBe(FanControl.FanMode.High);
+		});
+
+		it('should map negative windStrength to High mode', () => {
+			const mode = mapWindStrengthToFixedFanMode(-1);
+			expect(mode).toBe(FanControl.FanMode.High);
+		});
+
+		it('should map zero windStrength to High mode', () => {
+			const mode = mapWindStrengthToFixedFanMode(0);
+			expect(mode).toBe(FanControl.FanMode.High);
+		});
+	});
+});