@@ -2,7 +2,7 @@
 
 A Home Assistant integration for intelligent EV charging control based on solar production, time of day, and battery levels.
 
-## Current Version: 0.9.10
+## Current Version: 0.9.11
 
 [![GitHub Release](https://img.shields.io/github/v/release/antbald/ha-ev-smart-charger)](https://github.com/antbald/ha-ev-smart-charger/releases)
 [![hacs_badge](https://img.shields.io/badge/HACS-Custom-orange.svg)](https://github.com/custom-components/hacs)
@@ -729,7 +729,60 @@ Then restart Home Assistant.
 
 ## Changelog
 
-### v0.9.10 (2025-10-29) - Current - Critical: Charger Start Fix in EV_FREE Mode
+### v0.9.11 (2025-10-29) - Current - Diagnostic Sensor & Detailed Error Reporting
+- **NEW: Solar Surplus Diagnostic Sensor** (`sensor.evsc_solar_surplus_diagnostic`)
+  - Real-time diagnostic information about solar surplus checks
+  - Shows current state (OK, ERROR, WAITING, etc.)
+  - Detailed attributes with all sensor values and check results
+  - Helps troubleshoot "unknown" sensor value errors
+  - Updates on every periodic check with comprehensive data
+
+- **FIX: Detailed error reporting for "unknown" sensor values**
+  - Previously: Generic error "could not convert string to float: 'unknown'"
+  - Now: **Specific identification of WHICH sensor has invalid value**
+  - Logs show:
+    - Sensor entity ID
+    - Current sensor value (e.g., "unknown", "unavailable", etc.)
+    - Exact error message
+  - Makes troubleshooting much easier
+
+- **Enhanced Error Logging:**
+  - Each sensor parsed individually with try/catch
+  - Collects all sensor errors before reporting
+  - Detailed error block shows:
+    - Solar Production entity & value
+    - Home Consumption entity & value
+    - Grid Import entity & value
+    - Specific error for each invalid sensor
+  - Diagnostic sensor updated with error details
+
+- **Example Error Output:**
+  ```
+  ❌ SENSOR ERROR DETAILS:
+     Solar Production (sensor.solar_production): 'unknown' - could not convert string to float: 'unknown'
+     Entity IDs to check:
+     - Solar Production: sensor.solar_production
+     - Home Consumption: sensor.home_consumption
+     - Grid Import: sensor.grid_import
+  ```
+
+- **Diagnostic Sensor Attributes:**
+  - `last_check`: ISO timestamp of last check
+  - `errors`: List of all sensor errors (if any)
+  - `solar_production_entity`: Entity ID
+  - `solar_production_value`: Current value
+  - `home_consumption_entity`: Entity ID
+  - `home_consumption_value`: Current value
+  - `grid_import_entity`: Entity ID
+  - `grid_import_value`: Current value
+  - *(More attributes added as development continues)*
+
+- **Files Modified:**
+  - `sensor.py` - Added `EVSCSolarSurplusDiagnosticSensor` class
+  - `solar_surplus.py` - Enhanced error handling, added diagnostic sensor updates, added datetime import
+  - `manifest.json` - Version 0.9.11
+
+### v0.9.10 (2025-10-29) - Critical: Charger Start Fix in EV_FREE Mode
 - **FIX: Charger now treats amperage as 0 when OFF, enabling proper start logic**
   - **Critical Issue**: When charger was OFF, `current_amps` was read from charger setting (e.g., 16A from previous session)
   - Solar surplus logic compared `target_amps` (e.g., 26A) vs `current_amps` (16A) → triggered increase (correct)
 
@@ -1,7 +1,7 @@
 {
   "domain": "ev_smart_charger",
   "name": "EV Smart Charger",
-  "version": "0.9.10",
+  "version": "0.9.11",
   "documentation": "https://github.com/antbald/ha-ev-smart-charger",
   "issue_tracker": "https://github.com/antbald/ha-ev-smart-charger/issues",
   "codeowners": ["@antbald"],
 
@@ -43,6 +43,16 @@ async def async_setup_entry(
         )
     )
 
+    # Create Solar Surplus Diagnostic Sensor
+    entities.append(
+        EVSCSolarSurplusDiagnosticSensor(
+            entry.entry_id,
+            "evsc_solar_surplus_diagnostic",
+            "EVSC Solar Surplus Diagnostic",
+            "mdi:solar-power",
+        )
+    )
+
     async_add_entities(entities)
     _LOGGER.info(f"✅ Created {len(entities)} EVSC sensors")
 
@@ -117,3 +127,40 @@ async def async_added_to_hass(self) -> None:
             self._attr_native_value = last_state.state
             if last_state.attributes:
                 self._attr_extra_state_attributes = dict(last_state.attributes)
+
+
+class EVSCSolarSurplusDiagnosticSensor(SensorEntity, RestoreEntity):
+    """EVSC Solar Surplus Diagnostic Sensor with detailed check information."""
+
+    _attr_should_poll = False
+
+    def __init__(
+        self,
+        entry_id: str,
+        suffix: str,
+        name: str,
+        icon: str,
+    ) -> None:
+        """Initialize the solar surplus diagnostic sensor."""
+        self._attr_unique_id = f"{DOMAIN}_{entry_id}_{suffix}"
+        self._attr_name = name
+        self._attr_icon = icon
+        self._attr_native_value = "Waiting for first check"
+        self._attr_extra_state_attributes = {}
+        # Set explicit entity_id to match pattern
+        self.entity_id = f"sensor.{DOMAIN}_{entry_id}_{suffix}"
+
+    @property
+    def extra_state_attributes(self) -> dict:
+        """Return the state attributes."""
+        return self._attr_extra_state_attributes
+
+    async def async_added_to_hass(self) -> None:
+        """Restore last state."""
+        await super().async_added_to_hass()
+        _LOGGER.info(f"✅ Solar Surplus Diagnostic sensor registered: {self.entity_id} (unique_id: {self.unique_id})")
+
+        if (last_state := await self.async_get_last_state()) is not None:
+            self._attr_native_value = last_state.state
+            if last_state.attributes:
+                self._attr_extra_state_attributes = dict(last_state.attributes)
@@ -1,7 +1,7 @@
 """Solar Surplus Charging Profile automation."""
 from __future__ import annotations
 import logging
-from datetime import timedelta
+from datetime import timedelta, datetime
 
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.event import async_track_time_interval
@@ -81,6 +81,7 @@ def __init__(
         self._home_min_soc_saturday_entity = None
         self._home_min_soc_sunday_entity = None
         self._priority_state_sensor_entity = None
+        self._solar_surplus_diagnostic_sensor_entity = None
 
         # Timer for periodic checks
         self._timer_unsub = None
@@ -141,6 +142,7 @@ async def async_setup(self) -> None:
         self._home_min_soc_saturday_entity = self._find_entity_by_suffix("evsc_home_min_soc_saturday")
         self._home_min_soc_sunday_entity = self._find_entity_by_suffix("evsc_home_min_soc_sunday")
         self._priority_state_sensor_entity = self._find_entity_by_suffix("evsc_priority_daily_state")
+        self._solar_surplus_diagnostic_sensor_entity = self._find_entity_by_suffix("evsc_solar_surplus_diagnostic")
 
         if not all([
             self._forza_ricarica_entity,
@@ -530,30 +532,97 @@ async def _async_periodic_check(self, now=None) -> None:
             _LOGGER.info("=" * 80)
             return
 
-        # Parse values
+        # Parse values with detailed error reporting
+        sensor_values = {}
+        sensor_errors = []
+
         try:
-            fv_production = float(fv_state.state)
-            home_consumption = float(consumption_state.state)
-            grid_import = float(grid_import_state.state)
-            grid_threshold = float(grid_threshold_state.state)
-            grid_import_delay = float(grid_delay_state.state)
-            surplus_drop_delay = float(surplus_delay_state.state)
-            use_home_battery = use_battery_state.state == "on"
-            battery_min_soc = float(battery_min_soc_state.state)
-
-            # Home battery SOC (optional)
-            home_battery_soc = None
-            if soc_home_state and use_home_battery:
-                try:
-                    home_battery_soc = float(soc_home_state.state)
-                except (ValueError, TypeError):
-                    _LOGGER.warning("⚠️ Home Battery SOC value invalid, treating as unavailable")
+            sensor_values["fv_production"] = float(fv_state.state)
+        except (ValueError, TypeError) as e:
+            sensor_errors.append(f"Solar Production ({self._fv_production}): '{fv_state.state}' - {e}")
+
+        try:
+            sensor_values["home_consumption"] = float(consumption_state.state)
+        except (ValueError, TypeError) as e:
+            sensor_errors.append(f"Home Consumption ({self._home_consumption}): '{consumption_state.state}' - {e}")
+
+        try:
+            sensor_values["grid_import"] = float(grid_import_state.state)
+        except (ValueError, TypeError) as e:
+            sensor_errors.append(f"Grid Import ({self._grid_import}): '{grid_import_state.state}' - {e}")
+
+        try:
+            sensor_values["grid_threshold"] = float(grid_threshold_state.state)
+        except (ValueError, TypeError) as e:
+            sensor_errors.append(f"Grid Threshold: '{grid_threshold_state.state}' - {e}")
+
+        try:
+            sensor_values["grid_import_delay"] = float(grid_delay_state.state)
+        except (ValueError, TypeError) as e:
+            sensor_errors.append(f"Grid Import Delay: '{grid_delay_state.state}' - {e}")
 
+        try:
+            sensor_values["surplus_drop_delay"] = float(surplus_delay_state.state)
+        except (ValueError, TypeError) as e:
+            sensor_errors.append(f"Surplus Drop Delay: '{surplus_delay_state.state}' - {e}")
+
+        try:
+            sensor_values["battery_min_soc"] = float(battery_min_soc_state.state)
         except (ValueError, TypeError) as e:
-            _LOGGER.warning(f"⚠️ Decision: Invalid sensor values: {e}")
+            sensor_errors.append(f"Home Battery Min SOC: '{battery_min_soc_state.state}' - {e}")
+
+        sensor_values["use_home_battery"] = use_battery_state.state == "on"
+
+        # Home battery SOC (optional)
+        home_battery_soc = None
+        if soc_home_state and sensor_values.get("use_home_battery"):
+            try:
+                home_battery_soc = float(soc_home_state.state)
+            except (ValueError, TypeError):
+                _LOGGER.warning(f"⚠️ Home Battery SOC ({self._soc_home}) value invalid: '{soc_home_state.state}', treating as unavailable")
+
+        # If there are any errors, log them and update diagnostic sensor
+        if sensor_errors:
+            _LOGGER.error("=" * 80)
+            _LOGGER.error("❌ SENSOR ERROR DETAILS:")
+            for error in sensor_errors:
+                _LOGGER.error(f"   {error}")
+            _LOGGER.error("=" * 80)
+            _LOGGER.error("⚠️ Decision: Cannot proceed with solar surplus check due to invalid sensor values")
+            _LOGGER.error("   Please check that all configured sensors are providing valid numeric values")
+            _LOGGER.error("   Entity IDs to check:")
+            _LOGGER.error(f"   - Solar Production: {self._fv_production}")
+            _LOGGER.error(f"   - Home Consumption: {self._home_consumption}")
+            _LOGGER.error(f"   - Grid Import: {self._grid_import}")
             _LOGGER.info("=" * 80)
+
+            # Update diagnostic sensor with error details
+            if self._solar_surplus_diagnostic_sensor_entity:
+                await self._update_diagnostic_sensor(
+                    state="ERROR: Invalid sensor values",
+                    attributes={
+                        "last_check": datetime.now().isoformat(),
+                        "errors": sensor_errors,
+                        "solar_production_entity": self._fv_production,
+                        "home_consumption_entity": self._home_consumption,
+                        "grid_import_entity": self._grid_import,
+                        "solar_production_value": fv_state.state,
+                        "home_consumption_value": consumption_state.state,
+                        "grid_import_value": grid_import_state.state,
+                    }
+                )
             return
 
+        # Extract parsed values
+        fv_production = sensor_values["fv_production"]
+        home_consumption = sensor_values["home_consumption"]
+        grid_import = sensor_values["grid_import"]
+        grid_threshold = sensor_values["grid_threshold"]
+        grid_import_delay = sensor_values["grid_import_delay"]
+        surplus_drop_delay = sensor_values["surplus_drop_delay"]
+        use_home_battery = sensor_values["use_home_battery"]
+        battery_min_soc = sensor_values["battery_min_soc"]
+
         # Get current amperage - treat as 0 if charger is OFF
         charger_state = self.hass.states.get(self._charger_switch)
         charger_is_on = charger_state and charger_state.state == "on"
@@ -829,6 +898,17 @@ async def _adjust_amperage_down_one_step(self, target_amps: int) -> None:
             _LOGGER.info("   3/5: Target is 0A, keeping charger off")
             _LOGGER.info("✅ Charger stopped")
 
+    async def _update_diagnostic_sensor(self, state: str, attributes: dict) -> None:
+        """Update the solar surplus diagnostic sensor with current check information."""
+        if not self._solar_surplus_diagnostic_sensor_entity:
+            return
+
+        self.hass.states.async_set(
+            self._solar_surplus_diagnostic_sensor_entity,
+            state,
+            attributes,
+        )
+
     async def async_remove(self) -> None:
         """Remove the automation."""
         if self._timer_unsub:
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"domain": "ev_smart_charger",`
`3`	`3`	`"name": "EV Smart Charger",`
`4`		`- "version": "0.9.10",`
	`4`	`+ "version": "0.9.11",`
`5`	`5`	`"documentation": "https://github.com/antbald/ha-ev-smart-charger",`
`6`	`6`	`"issue_tracker": "https://github.com/antbald/ha-ev-smart-charger/issues",`
`7`	`7`	`"codeowners": ["@antbald"],`