feat: Add remote temperature sensor support (experimental)

Allow the AC to use an external temperature sensor (e.g., room average)
instead of its internal sensor for temperature regulation.

This feature is gated behind an "Enable experimental features" toggle
in the integration options. Users must explicitly opt-in to access
the remote temperature functionality.

Changes:
- Add experimental features toggle in options flow
- Add Temperature Source selector entity (Internal/Remote) when enabled
- Add external temperature entity configuration when enabled
- Send configured sensor temperature to AC on each update cycle
- Persist remote/internal mode to survive HA restarts
- Restore mode automatically on startup

The external temperature entity can be any HA sensor that reports
temperature (e.g., a template sensor averaging multiple room sensors).

Author: ashleigh-hopkins

custom_components/mitsubishi/__init__.py

@@ -62,7 +62,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             raise ConfigEntryNotReady(f"Unable to connect to Mitsubishi AC at {host}") from e
 
         # Create data update coordinator with custom scan interval
-        coordinator = MitsubishiDataUpdateCoordinator(hass, controller, scan_interval)
+        coordinator = MitsubishiDataUpdateCoordinator(hass, controller, entry, scan_interval)
 
         # Fetch unit info for device registry enrichment
         try:

custom_components/mitsubishi/config_flow.py

@@ -11,12 +11,16 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import AbortFlow
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import selector
 from pymitsubishi import MitsubishiAPI, MitsubishiController
 
 from .const import (
     CONF_ADMIN_PASSWORD,
     CONF_ADMIN_USERNAME,
     CONF_ENCRYPTION_KEY,
+    CONF_EXPERIMENTAL_FEATURES,
+    CONF_EXTERNAL_TEMP_ENTITY,
+    CONF_REMOTE_TEMP_MODE,
     CONF_SCAN_INTERVAL,
     DEFAULT_ADMIN_PASSWORD,
     DEFAULT_ADMIN_USERNAME,
@@ -139,18 +143,37 @@ async def async_step_init(self, user_input: dict[str, Any] | None = None) -> Any
         if user_input is not None:
             _LOGGER.debug("Processing options user input: %s", user_input)
             try:
-                # Validate the new configuration
+                # Separate options from connection data
+                experimental_features = user_input.pop(CONF_EXPERIMENTAL_FEATURES, False)
+                external_temp_entity = user_input.pop(CONF_EXTERNAL_TEMP_ENTITY, None)
+
+                # Validate the connection configuration
                 _LOGGER.debug("Validating new configuration")
                 await validate_input(self.hass, user_input)
                 _LOGGER.debug("Validation successful for options")
 
-                # Update the config entry with new data
-                self.hass.config_entries.async_update_entry(self._config_entry, data=user_input)
+                # Update the config entry data (connection settings)
+                self.hass.config_entries.async_update_entry(
+                    self._config_entry,
+                    data=user_input,
+                )
 
                 # Trigger reload of the integration to apply changes
                 await self.hass.config_entries.async_reload(self._config_entry.entry_id)
 
-                return self.async_create_entry(title="", data={})
+                # Build new options, preserving remote_temp_mode if it exists
+                new_options = {
+                    CONF_EXPERIMENTAL_FEATURES: experimental_features,
+                }
+                if experimental_features and external_temp_entity:
+                    new_options[CONF_EXTERNAL_TEMP_ENTITY] = external_temp_entity
+                # Preserve remote_temp_mode from existing options
+                if CONF_REMOTE_TEMP_MODE in self._config_entry.options:
+                    new_options[CONF_REMOTE_TEMP_MODE] = self._config_entry.options[
+                        CONF_REMOTE_TEMP_MODE
+                    ]
+
+                return self.async_create_entry(title="", data=new_options)
 
             except CannotConnect:
                 _LOGGER.error("Cannot connect to device with new settings")
@@ -173,18 +196,35 @@ async def async_step_init(self, user_input: dict[str, Any] | None = None) -> Any
         current_scan_interval = self._config_entry.data.get(
             CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL
         )
+        current_experimental = self._config_entry.options.get(CONF_EXPERIMENTAL_FEATURES, False)
+        current_external_temp_entity = self._config_entry.options.get(CONF_EXTERNAL_TEMP_ENTITY, "")
+
+        # Base schema with connection settings
+        schema_dict = {
+            vol.Required(CONF_HOST, default=current_host): str,
+            vol.Optional(CONF_ENCRYPTION_KEY, default=current_encryption_key): str,
+            vol.Optional(CONF_ADMIN_USERNAME, default=current_admin_username): str,
+            vol.Optional(CONF_ADMIN_PASSWORD, default=current_admin_password): str,
+            vol.Optional(CONF_SCAN_INTERVAL, default=current_scan_interval): vol.All(
+                vol.Coerce(int), vol.Range(min=10, max=300)
+            ),
+            vol.Optional(CONF_EXPERIMENTAL_FEATURES, default=current_experimental): bool,
+        }
 
-        options_schema = vol.Schema(
-            {
-                vol.Required(CONF_HOST, default=current_host): str,
-                vol.Optional(CONF_ENCRYPTION_KEY, default=current_encryption_key): str,
-                vol.Optional(CONF_ADMIN_USERNAME, default=current_admin_username): str,
-                vol.Optional(CONF_ADMIN_PASSWORD, default=current_admin_password): str,
-                vol.Optional(CONF_SCAN_INTERVAL, default=current_scan_interval): vol.All(
-                    vol.Coerce(int), vol.Range(min=10, max=300)
-                ),
-            }
-        )
+        # Only show external temp entity selector if experimental features are enabled
+        if current_experimental:
+            schema_dict[
+                vol.Optional(
+                    CONF_EXTERNAL_TEMP_ENTITY,
+                    description={"suggested_value": current_external_temp_entity},
+                )
+            ] = selector.EntitySelector(
+                selector.EntitySelectorConfig(
+                    domain=["sensor", "input_number", "number"],
+                )
+            )
+
+        options_schema = vol.Schema(schema_dict)
 
         return self.async_show_form(step_id="init", data_schema=options_schema, errors=errors)
 

custom_components/mitsubishi/const.py

@@ -13,3 +13,14 @@
 CONF_ADMIN_PASSWORD = "admin_password"
 DEFAULT_ADMIN_PASSWORD = "me1debug@0567"
 CONF_SCAN_INTERVAL = "scan_interval"
+
+# Experimental Features
+CONF_EXPERIMENTAL_FEATURES = "experimental_features"
+
+# Remote Temperature Configuration (experimental)
+CONF_EXTERNAL_TEMP_ENTITY = "external_temperature_entity"
+CONF_REMOTE_TEMP_MODE = "remote_temp_mode"
+
+# Temperature Source Modes
+TEMP_SOURCE_INTERNAL = "internal"
+TEMP_SOURCE_REMOTE = "remote"

custom_components/mitsubishi/coordinator.py

@@ -5,11 +5,19 @@
 import logging
 from datetime import timedelta
 
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from pymitsubishi import MitsubishiController, ParsedDeviceState
 
-from .const import DEFAULT_SCAN_INTERVAL, DOMAIN
+from .const import (
+    CONF_EXPERIMENTAL_FEATURES,
+    CONF_EXTERNAL_TEMP_ENTITY,
+    CONF_REMOTE_TEMP_MODE,
+    DEFAULT_SCAN_INTERVAL,
+    DOMAIN,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -21,11 +29,16 @@ def __init__(
         self,
         hass: HomeAssistant,
         controller: MitsubishiController,
+        config_entry: ConfigEntry,
         scan_interval: int = DEFAULT_SCAN_INTERVAL,
     ) -> None:
         """Initialize."""
         self.controller = controller
+        self.config_entry = config_entry
         self.unit_info = None  # Will be populated on first update or by config flow
+        # Load persisted remote temperature mode (AC doesn't report it, so we track it)
+        self._remote_temp_mode = config_entry.options.get(CONF_REMOTE_TEMP_MODE, False)
+        self._startup_mode_applied = False
 
         super().__init__(
             hass,
@@ -34,16 +47,110 @@ def __init__(
             update_interval=timedelta(seconds=scan_interval),
         )
 
+    def set_remote_temp_mode(self, enabled: bool) -> None:
+        """Set whether remote temperature mode is enabled and persist to storage."""
+        self._remote_temp_mode = enabled
+        _LOGGER.info("Remote temperature mode set to: %s", enabled)
+
+        # Persist to config entry options
+        new_options = dict(self.config_entry.options)
+        new_options[CONF_REMOTE_TEMP_MODE] = enabled
+        self.hass.config_entries.async_update_entry(
+            self.config_entry,
+            options=new_options,
+        )
+
+    @property
+    def remote_temp_mode(self) -> bool:
+        """Return whether remote temperature mode is enabled."""
+        return self._remote_temp_mode
+
+    @property
+    def experimental_features_enabled(self) -> bool:
+        """Return whether experimental features are enabled."""
+        return self.config_entry.options.get(CONF_EXPERIMENTAL_FEATURES, False)
+
     async def get_unit_info(self) -> dict:
         """Fetch unit information once for device info."""
         unit_info = await self.hass.async_add_executor_job(self.controller.get_unit_info)
         return unit_info
 
     async def _async_update_data(self) -> ParsedDeviceState:
         """Update data via library."""
-        _LOGGER.info("Coordinator fetching device status")
-        # This invokes a network call, run in executor to avoid blocking
+        _LOGGER.debug("Coordinator fetching device status")
+
+        # Only process remote temperature if experimental features are enabled
+        if self.experimental_features_enabled:
+            # On first update after startup, restore the persisted mode to the AC
+            if not self._startup_mode_applied:
+                self._startup_mode_applied = True
+                if self._remote_temp_mode:
+                    _LOGGER.info("Restoring remote temperature mode from persisted state")
+                    await self._send_remote_temperature()
+                else:
+                    _LOGGER.debug("Starting with internal temperature mode")
+            elif self._remote_temp_mode:
+                # Regular update - send remote temperature if enabled
+                await self._send_remote_temperature()
+        else:
+            self._startup_mode_applied = True
+
+        # Fetch status from device
         state = await self.hass.async_add_executor_job(
             self.controller.fetch_status,
         )
         return state
+
+    async def _send_remote_temperature(self) -> None:
+        """Send remote temperature to AC if configured and available."""
+        external_entity_id = self.config_entry.options.get(CONF_EXTERNAL_TEMP_ENTITY)
+
+        if not external_entity_id:
+            _LOGGER.warning(
+                "Remote temperature mode enabled but no external entity configured, "
+                "falling back to internal sensor"
+            )
+            await self.hass.async_add_executor_job(self.controller.set_current_temperature, None)
+            self._remote_temp_mode = False
+            return
+
+        state = self.hass.states.get(external_entity_id)
+
+        if state is None:
+            _LOGGER.warning(
+                "External temperature entity %s not found, falling back to internal sensor",
+                external_entity_id,
+            )
+            await self.hass.async_add_executor_job(self.controller.set_current_temperature, None)
+            self._remote_temp_mode = False
+            return
+
+        if state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
+            _LOGGER.warning(
+                "External temperature entity %s is %s, falling back to internal sensor",
+                external_entity_id,
+                state.state,
+            )
+            await self.hass.async_add_executor_job(self.controller.set_current_temperature, None)
+            self._remote_temp_mode = False
+            return
+
+        try:
+            temperature = float(state.state)
+            _LOGGER.debug(
+                "Sending remote temperature %.1f from %s to AC",
+                temperature,
+                external_entity_id,
+            )
+            await self.hass.async_add_executor_job(
+                self.controller.set_current_temperature, temperature
+            )
+        except (ValueError, TypeError) as e:
+            _LOGGER.error(
+                "Invalid temperature value '%s' from %s: %s, falling back to internal sensor",
+                state.state,
+                external_entity_id,
+                e,
+            )
+            await self.hass.async_add_executor_job(self.controller.set_current_temperature, None)
+            self._remote_temp_mode = False