feat: Add remote temperature sensor support

ashleigh-hopkins · ashleigh-hopkins · commit b7eeaa7ae3f5 · 2026-01-24T18:27:41.000Z
Allow the AC to use an external temperature sensor (e.g., room average)
instead of its internal sensor for temperature regulation.

Changes:
- Add Temperature Source selector entity (Internal/Remote)
- Add external temperature entity configuration in options flow
- 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).
diff --git a/custom_components/mitsubishi/__init__.py b/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:
diff --git a/custom_components/mitsubishi/config_flow.py b/custom_components/mitsubishi/config_flow.py
@@ -8,6 +8,7 @@
 import voluptuous as vol
 from homeassistant import config_entries
 from homeassistant.const import CONF_HOST
+from homeassistant.helpers import selector
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import AbortFlow
 from homeassistant.exceptions import HomeAssistantError
@@ -17,6 +18,7 @@
     CONF_ADMIN_PASSWORD,
     CONF_ADMIN_USERNAME,
     CONF_ENCRYPTION_KEY,
+    CONF_EXTERNAL_TEMP_ENTITY,
     CONF_SCAN_INTERVAL,
     DEFAULT_ADMIN_PASSWORD,
     DEFAULT_ADMIN_USERNAME,
@@ -139,18 +141,26 @@ 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 connection data from options
+                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={})
+                # Return options via async_create_entry (this sets config_entry.options)
+                new_options = {CONF_EXTERNAL_TEMP_ENTITY: external_temp_entity} if external_temp_entity else {}
+                return self.async_create_entry(title="", data=new_options)
 
             except CannotConnect:
                 _LOGGER.error("Cannot connect to device with new settings")
@@ -173,6 +183,9 @@ 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_external_temp_entity = self._config_entry.options.get(
+            CONF_EXTERNAL_TEMP_ENTITY, ""
+        )
 
         options_schema = vol.Schema(
             {
@@ -183,6 +196,14 @@ async def async_step_init(self, user_input: dict[str, Any] | None = None) -> Any
                 vol.Optional(CONF_SCAN_INTERVAL, default=current_scan_interval): vol.All(
                     vol.Coerce(int), vol.Range(min=10, max=300)
                 ),
+                vol.Optional(
+                    CONF_EXTERNAL_TEMP_ENTITY,
+                    description={"suggested_value": current_external_temp_entity},
+                ): selector.EntitySelector(
+                    selector.EntitySelectorConfig(
+                        domain=["sensor", "input_number", "number"],
+                    )
+                ),
             }
         )
 
diff --git a/custom_components/mitsubishi/const.py b/custom_components/mitsubishi/const.py
@@ -13,3 +13,11 @@
 CONF_ADMIN_PASSWORD = "admin_password"
 DEFAULT_ADMIN_PASSWORD = "me1debug@0567"
 CONF_SCAN_INTERVAL = "scan_interval"
+
+# Remote Temperature Configuration
+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"
diff --git a/custom_components/mitsubishi/coordinator.py b/custom_components/mitsubishi/coordinator.py
@@ -5,11 +5,13 @@
 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_EXTERNAL_TEMP_ENTITY, CONF_REMOTE_TEMP_MODE, DEFAULT_SCAN_INTERVAL, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -21,11 +23,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 +41,109 @@ 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
+
     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")
+
+        # 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()
+
+        # 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
diff --git a/custom_components/mitsubishi/select.py b/custom_components/mitsubishi/select.py
@@ -2,17 +2,21 @@
 
 from __future__ import annotations
 
+import logging
 from typing import Any
 
 from homeassistant.components.select import SelectEntity
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
-from .const import DOMAIN
+from .const import CONF_EXTERNAL_TEMP_ENTITY, DOMAIN, TEMP_SOURCE_INTERNAL, TEMP_SOURCE_REMOTE
 from .coordinator import MitsubishiDataUpdateCoordinator
 from .entity import MitsubishiEntity
 
+_LOGGER = logging.getLogger(__name__)
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -24,6 +28,7 @@ async def async_setup_entry(
     async_add_entities(
         [
             MitsubishiPowerSavingSelect(coordinator, config_entry),
+            MitsubishiTemperatureSourceSelect(coordinator, config_entry),
         ]
     )
 
@@ -64,3 +69,93 @@ async def async_select_option(self, option: str) -> None:
     def extra_state_attributes(self) -> dict[str, Any]:
         """Return entity specific state attributes."""
         return {"source": "Mitsubishi AC"}
+
+
+class MitsubishiTemperatureSourceSelect(MitsubishiEntity, SelectEntity):
+    """Temperature source mode select for Mitsubishi AC."""
+
+    _attr_name = "Temperature Source"
+    _attr_icon = "mdi:thermometer"
+    _attr_options = ["Internal", "Remote"]
+
+    def __init__(
+        self,
+        coordinator: MitsubishiDataUpdateCoordinator,
+        config_entry: ConfigEntry,
+    ) -> None:
+        """Initialize the temperature source select."""
+        super().__init__(coordinator, config_entry, "temperature_source_select")
+        self._config_entry = config_entry
+
+    @property
+    def current_option(self) -> str | None:
+        """Return the current temperature source mode."""
+        return "Remote" if self.coordinator.remote_temp_mode else "Internal"
+
+    async def async_select_option(self, option: str) -> None:
+        """Set the temperature source mode."""
+        if option == "Internal":
+            # Switch to internal sensor
+            self.coordinator.set_remote_temp_mode(False)
+            await self.hass.async_add_executor_job(
+                self.coordinator.controller.set_current_temperature,
+                None,
+            )
+            _LOGGER.info("Switched to internal temperature sensor")
+        else:
+            # Switch to remote sensor - check if external entity is configured
+            external_entity_id = self._config_entry.options.get(CONF_EXTERNAL_TEMP_ENTITY)
+            if not external_entity_id:
+                _LOGGER.warning(
+                    "Cannot switch to remote mode: No external temperature entity configured. "
+                    "Configure one in the integration options first."
+                )
+                return
+
+            # Check if the entity is available
+            state = self.hass.states.get(external_entity_id)
+            if state is None or state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
+                _LOGGER.warning(
+                    "Cannot switch to remote mode: External entity %s is not available",
+                    external_entity_id,
+                )
+                return
+
+            try:
+                temp = float(state.state)
+            except (ValueError, TypeError):
+                _LOGGER.warning(
+                    "Cannot switch to remote mode: Invalid temperature value from %s",
+                    external_entity_id,
+                )
+                return
+
+            # Enable remote mode and send the temperature
+            self.coordinator.set_remote_temp_mode(True)
+            await self.hass.async_add_executor_job(
+                self.coordinator.controller.set_current_temperature,
+                temp,
+            )
+            _LOGGER.info(
+                "Switched to remote temperature sensor (%s: %.1f)",
+                external_entity_id,
+                temp,
+            )
+
+        self.async_write_ha_state()
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any]:
+        """Return entity specific state attributes."""
+        attrs = {"source": "Mitsubishi AC"}
+        external_entity_id = self._config_entry.options.get(CONF_EXTERNAL_TEMP_ENTITY)
+        if external_entity_id:
+            attrs["external_temperature_entity"] = external_entity_id
+            # Get current value from external entity
+            state = self.hass.states.get(external_entity_id)
+            if state and state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN):
+                try:
+                    attrs["external_temperature"] = float(state.state)
+                except (ValueError, TypeError):
+                    attrs["external_temperature"] = None
+        return attrs
diff --git a/custom_components/mitsubishi/strings.json b/custom_components/mitsubishi/strings.json
@@ -33,7 +33,11 @@
           "admin_username": "Admin Username (default: admin)",
           "admin_password": "Admin Password (default: me1debug@0567)",
           "scan_interval": "Update Interval (seconds, 10-300)",
-          "enable_capability_detection": "Enable capability detection"
+          "enable_capability_detection": "Enable capability detection",
+          "external_temperature_entity": "External Temperature Sensor"
+        },
+        "data_description": {
+          "external_temperature_entity": "Select a temperature sensor to use as the room temperature when Remote mode is selected. Leave empty to only use the internal sensor."
         }
       }
     },

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,11 @@`
`33`	`33`	`"admin_username": "Admin Username (default: admin)",`
`34`	`34`	`"admin_password": "Admin Password (default: me1debug@0567)",`
`35`	`35`	`"scan_interval": "Update Interval (seconds, 10-300)",`
`36`		`- "enable_capability_detection": "Enable capability detection"`
	`36`	`+ "enable_capability_detection": "Enable capability detection",`
	`37`	`+ "external_temperature_entity": "External Temperature Sensor"`
	`38`	`+ },`
	`39`	`+ "data_description": {`
	`40`	`+ "external_temperature_entity": "Select a temperature sensor to use as the room temperature when Remote mode is selected. Leave empty to only use the internal sensor."`
`37`	`41`	`}`
`38`	`42`	`}`
`39`	`43`	`},`