6 Commits
30 changed files with 2353 additions and 67 deletions
+1
View File
@@ -0,0 +1 @@
buy_me_a_coffee: costea32
Regular → Executable
View File
+147
View File
@@ -0,0 +1,147 @@
# CLAUDE.md - AI Assistant Context
This file provides context for AI assistants working with this codebase.
## Project Overview
This is a **Home Assistant custom integration** for RDZ PDC heat pumps. It communicates with the heat pump's embedded web server via HTTP to monitor status and control temperatures.
**Domain**: `rdz_innova_heatpump`
## Architecture
```
custom_components/rdz_innova_heatpump/
├── __init__.py # Core: HeatPumpDataCoordinator, HeatPumpEntity base class, service registration
├── config_flow.py # UI configuration wizard (URL + scan interval)
├── climate.py # Climate entity for heating water temperature control
├── water_heater.py # Water heater entity for DHW (domestic hot water) control
├── sensor.py # Temperature sensors, runtime sensors, version sensor
├── binary_sensor.py # Status binary sensors (heating, cooling, pump, alarm, etc.)
├── manifest.json # Integration metadata
└── translations/en.json
```
## Key Components
### HeatPumpDataCoordinator (`__init__.py:88`)
Central data manager using Home Assistant's `DataUpdateCoordinator` pattern.
- Fetches JSON data from heat pump at configurable intervals (default 3s)
- Parses status response into normalized dict
- Provides `set_water_setpoint()` and `set_dhw_setpoint()` methods
### HeatPumpEntity (`__init__.py:224`)
Base class for all entities. Provides common device_info linking all entities to "Heat Pump" device.
### API Endpoints
- **GET Status**: Configurable URL (typically `index.php?Action=GetStatus`)
- **POST SetParameter**: `<base_url>/index.php?Action=SetParameter` with form data:
- `Key`: "watersetpoint" or "dhwsetpoint"
- `Value`: temperature string
- `manual`: duration ("forever" or time-based)
## Data Flow
1. User configures URL via config_flow
2. Coordinator fetches JSON every N seconds
3. JSON parsed into normalized dict with keys like `water_temp_t1`, `is_heating`, etc.
4. Platform entities read from `coordinator.data`
5. Climate/water_heater call coordinator methods to set temperatures
## JSON Response Structure
Heat pump returns nested JSON. Key path: `RESULT.status.*`
```python
# Main data extraction in __init__.py:122-158
status = data.get("RESULT", {}).get("status", {})
```
**Critical fields:**
| Internal Key | JSON Path | Notes |
|--------------|-----------|-------|
| water_temp_t1 | status.watert1 | Inflow temperature |
| water_temp_t2 | status.watert2 | Outflow temperature |
| dhw_temp_t3 | status.dhwt3 | Domestic hot water temp |
| outdoor_temp_t4 | status.t4 | Outdoor temperature |
| water_setpoint | status.watersetpoint | Heating target |
| dhw_setpoint | status.dhwsetpoint | DHW target |
| inlet_setpoint_temp | status.ISP | Smart setpoint (parse: "34.3 °C" -> 34.3) |
| is_heating | status.heating | Boolean |
| is_cooling | status.cooling | Boolean |
| is_working | status.pwr | Compressor running |
| is_dhw | status.san | DHW mode active |
| is_pump_active | status.pump | Circulation pump |
| is_aux_heater | status.res | Backup heater |
| is_standby | status.standby | Standby mode |
| has_alarm | status.alarm.status | Alarm active |
## Firmware Variations
Different firmware versions have different JSON structures. Sample responses in `jsons/`:
| File | Version | Key Differences |
|------|---------|-----------------|
| og.json | v3.0.49 | Has ISP, SSP, res, sce fields; ISP is string with unit |
| bogdan.json | v2.3.2 | Missing ISP/SSP; simpler alarm structure; different temp ranges |
**Common issues requiring code modification:**
- `ISP` field may not exist or have different format
- `alarm.status` vs just `alarm.type`
- Field names may vary
## Entities Created
**Climate** (1):
- `climate.heat_pump_water_temperature` - Heating water thermostat
**Water Heater** (1):
- `water_heater.heat_pump_dhw` - DHW temperature control
**Sensors** (12):
- Temperature sensors: inlet_setpoint, system_setpoint, t1, t2, t3, t4, water_setpoint, dhw_setpoint, aux_heater
- Runtime sensors: worktime_pdc, worktime_res
- Info: software_version
**Binary Sensors** (10):
- heating, cooling, working, dhw_mode, water_pump, auxiliary_heater, standby, disabled_prod, sce, alarm
## Services
```yaml
# Set heating water temperature
service: rdz_innova_heatpump.set_water_setpoint
data:
temperature: 45.0 # 35-60°C
duration: "forever"
```
## Development Notes
### Adding New Sensors
1. Add field extraction in `HeatPumpDataCoordinator._async_update_data()`
2. Add sensor definition in `sensor.py` or `binary_sensor.py`
3. Reference via `self.coordinator.data.get("field_name")`
### Debugging
- Check HA logs for `rdz_innova_heatpump` domain
- Test URL manually in browser to verify JSON response
- Compare response against `jsons/*.json` samples
### Temperature Ranges
- Water setpoint: 35-60°C (hardcoded in service schema and climate entity)
- DHW setpoint: 35-60°C
- Step: 0.5°C
## File Purposes Quick Reference
| File | Purpose |
|------|---------|
| `__init__.py` | Coordinator, base entity, service registration, data parsing |
| `config_flow.py` | UI setup wizard |
| `climate.py` | Heating water thermostat |
| `water_heater.py` | DHW thermostat |
| `sensor.py` | Temperature and runtime sensors |
| `binary_sensor.py` | Status on/off sensors |
| `dashboards/dash.yaml` | Example Lovelace dashboard |
| `jsons/*.json` | Sample API responses for testing/reference |
Regular → Executable
+205 -20
View File
@@ -1,29 +1,214 @@
# README # # RDZ PDC Heat Pump Monitor - Home Assistant Integration
This README would normally document whatever steps are necessary to get your application up and running. A custom Home Assistant integration for monitoring and controlling RDZ PDC heat pumps via their embedded web interface.
### What is this repository for? ### ## Features
* Quick summary - **Climate Control**: Thermostat entity for controlling heating/cooling water temperature
* Version - **Water Heater Control**: Dedicated entity for domestic hot water (DHW) temperature control
* [Learn Markdown](https://bitbucket.org/tutorials/markdowndemo) - **Comprehensive Monitoring**: 12+ sensors for temperatures, setpoints, and runtime statistics
- **Status Indicators**: 10 binary sensors for operational states (heating, cooling, pump, alarms, etc.)
- **Local Polling**: Direct communication with heat pump - no cloud dependency
- **Dashboard Included**: Pre-configured Lovelace dashboard YAML
### How do I get set up? ### ## Supported Data Points
* Summary of set up ### Temperature Sensors
* Configuration | Sensor | Description |
* Dependencies |--------|-------------|
* Database configuration | Inlet Setpoint (ISP) | Smart heating setpoint temperature |
* How to run tests | System Setpoint (SSP) | System setpoint temperature |
* Deployment instructions | Water T1 | Inflow/supply water temperature |
| Water T2 | Outflow/return water temperature |
| DHW T3 | Domestic hot water temperature |
| Outdoor T4 | External/outdoor temperature |
| Water Setpoint | Target heating water temperature |
| DHW Setpoint | Target domestic hot water temperature |
### Contribution guidelines ### ### Binary Status Sensors
| Sensor | Description |
|--------|-------------|
| Heating | Heat pump is in heating mode |
| Cooling | Heat pump is in cooling mode |
| Working | Compressor is running |
| DHW Mode | Domestic hot water heating active |
| Water Pump | Circulation pump is active |
| Auxiliary Heater | Backup electric heater running |
| Standby | System in standby mode |
| Alarm | System alarm active |
* Writing tests ### Runtime Statistics
* Code review | Sensor | Description |
* Other guidelines |--------|-------------|
| Runtime (PDC) | Total compressor operating hours |
| Auxiliary Heater Runtime | Total backup heater operating hours |
### Who do I talk to? ### ## Installation
* Repo owner or admin ### Step 1: Copy Integration Files
* Other community or team contact
Copy the `custom_components/rdz_innova_heatpump` folder to your Home Assistant `custom_components` directory:
```
<config_directory>/
└── custom_components/
└── rdz_innova_heatpump/
├── __init__.py
├── climate.py
├── sensor.py
├── binary_sensor.py
├── water_heater.py
├── config_flow.py
├── manifest.json
└── translations/
└── en.json
```
### Step 2: Restart Home Assistant
After copying the files, restart Home Assistant completely.
### Step 3: Add Integration
1. Go to **Settings** → **Devices & Services**
2. Click **+ Add Integration**
3. Search for "RDZ" or "Heat Pump Monitor"
4. Follow the configuration wizard
### Step 4: Configure URL
When prompted, enter your heat pump's status URL. The format is typically:
```
http://<HEAT_PUMP_IP>/installedplugin/com.innova.pdc/<VERSION>/server/index.php?Action=GetStatus
```
**Example:**
```
http://192.168.11.101/installedplugin/com.innova.pdc/2.0.10/server/index.php?Action=GetStatus
```
**To find your URL:**
1. Access your heat pump's web interface in a browser
2. Open browser developer tools (F12)
3. Navigate to the Network tab
4. Look for requests to `index.php?Action=GetStatus`
5. Copy the full URL
**Verify your URL works** by opening it in a browser - you should see a JSON response like:
```json
{
"success": true,
"sw": { "V": "3.0.49" },
"RESULT": {
"status": { ... }
}
}
```
## Troubleshooting
### JSON Field Mapping Issues
Different firmware versions may have different JSON structures. If you encounter issues, you may need to modify the field mappings in `__init__.py`.
**Known differences between firmware versions:**
| Field | v3.0.49+ | v2.3.x |
|-------|----------|--------|
| ISP (Inlet Setpoint) | `"34.3 °C"` (string with unit) | May not exist |
| SSP (System Setpoint) | Present | May not exist |
| alarm.status | `true/false` | May only have `type` field |
| res (aux heater) | Present | May not exist |
| sce | Present | May not exist |
**Key mappings to verify in `__init__.py`:**
```python
"inlet_setpoint_temp": float(status.get("ISP", "0").split()[0]),
"system_setpoint_temp": status.get("SSP"),
"water_temp_t1": status.get("watert1"),
"water_temp_t2": status.get("watert2"),
"dhw_temp_t3": status.get("dhwt3"),
"outdoor_temp_t4": status.get("t4"),
"water_setpoint": status.get("watersetpoint"),
"dhw_setpoint": status.get("dhwsetpoint"),
"is_heating": status.get("heating", False),
"is_working": status.get("pwr", False),
"is_cooling": status.get("cooling", False),
"is_dhw": status.get("san", False),
"is_pump_active": status.get("pump", False),
"is_aux_heater": status.get("res", False),
"is_standby": status.get("standby", False),
```
### Common Issues
1. **Integration not appearing**: Ensure files are in the correct directory and restart HA completely
2. **Connection failed**: Verify the URL is accessible from your HA server
3. **Missing sensors**: Check if your firmware version supports all fields
4. **Temperature readings incorrect**: Verify JSON field names match your heat pump's response
## Dashboard
A pre-configured dashboard is included in `dashboards/dash.yaml`. To use it:
1. Copy the YAML content
2. Go to **Settings** → **Dashboards**
3. Create a new dashboard or edit existing
4. Use the raw configuration editor to paste the YAML
The dashboard includes:
- Status buttons (Alarm, Heating, Cooling, SCE, Standby)
- Thermostat cards for water and DHW control
- 24-hour history graph
- Scheduler integration (requires [scheduler-card](https://github.com/nielsfaber/scheduler-card))
## Services
### `rdz_innova_heatpump.set_water_setpoint`
Manually set the heating water setpoint temperature.
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| temperature | float | Yes | Target temperature (35-60°C) |
| duration | string | No | Duration: "forever" or time-based |
**Example:**
```yaml
service: rdz_innova_heatpump.set_water_setpoint
data:
temperature: 45
duration: forever
```
## API Reference
### Data Fetching
- **Endpoint**: Configurable URL (typically `index.php?Action=GetStatus`)
- **Method**: GET
- **Update Interval**: Configurable (default: 3 seconds)
### Parameter Setting
- **Endpoint**: `<base_url>/index.php?Action=SetParameter`
- **Method**: POST (form-urlencoded)
- **Parameters**:
- `Key`: "watersetpoint" or "dhwsetpoint"
- `Value`: Temperature as string
- `manual`: Duration ("forever" or time limit)
## Technical Details
- **Domain**: `rdz_innova_heatpump`
- **IoT Class**: Local Polling
- **Platforms**: sensor, binary_sensor, climate, water_heater
- **Configuration**: UI-based (config_flow)
## Contributing
Contributions are welcome! If you have a different firmware version or heat pump model, please share your JSON response structure to help improve compatibility.
## License
This project is provided as-is for personal use with RDZ PDC heat pumps.
+12
View File
@@ -0,0 +1,12 @@
# https://www.home-assistant.io/integrations/default_config/
default_config:
# https://www.home-assistant.io/integrations/homeassistant/
homeassistant:
debug: true
# https://www.home-assistant.io/integrations/logger/
logger:
default: info
logs:
custom_components.integration_blueprint: debug
+130 -20
View File
@@ -1,26 +1,12 @@
""" """
Custom integration for heat pump monitoring via web interface. Custom integration for heat pump monitoring and control via web interface.
Place this code in custom_components/heat_pump_monitor/__init__.py Place this code in custom_components/rdz_innova_heatpump/__init__.py
""" """
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
async def async_setup(hass: HomeAssistant, config: dict) -> bool:
"""Set up the Heat Pump Monitor component."""
hass.data.setdefault(DOMAIN, {})
return True
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Unload a config entry."""
unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
if unload_ok:
hass.data[DOMAIN].pop(entry.entry_id)
return unload_ok
import asyncio import asyncio
import logging import logging
import aiohttp import aiohttp
from datetime import timedelta from datetime import timedelta
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant, ServiceCall
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ( from homeassistant.const import (
CONF_URL, CONF_URL,
@@ -32,12 +18,31 @@ from homeassistant.helpers.update_coordinator import (
DataUpdateCoordinator, DataUpdateCoordinator,
UpdateFailed, UpdateFailed,
) )
import voluptuous as vol
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
DOMAIN = "ha_rdz_pdc_config" DOMAIN = "rdz_innova_heatpump"
DEFAULT_SCAN_INTERVAL = 3 DEFAULT_SCAN_INTERVAL = 3
PLATFORMS = ["sensor", "binary_sensor"] # Add climate to the platforms
PLATFORMS = ["sensor", "binary_sensor", "climate", "water_heater"]
# Service constants
SERVICE_SET_WATER_SETPOINT = "set_water_setpoint"
ATTR_TEMPERATURE = "temperature"
ATTR_DURATION = "duration"
# Service schema
SET_WATER_SETPOINT_SCHEMA = vol.Schema({
vol.Required(ATTR_TEMPERATURE): vol.All(vol.Coerce(float), vol.Range(min=35, max=60)),
vol.Optional(ATTR_DURATION, default="forever"): cv.string,
})
async def async_setup(hass: HomeAssistant, config: dict) -> bool:
"""Set up the Heat Pump Monitor component."""
hass.data.setdefault(DOMAIN, {})
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up heat pump monitor from a config entry.""" """Set up heat pump monitor from a config entry."""
@@ -56,9 +61,30 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
hass.data.setdefault(DOMAIN, {}) hass.data.setdefault(DOMAIN, {})
hass.data[DOMAIN][entry.entry_id] = coordinator hass.data[DOMAIN][entry.entry_id] = coordinator
# Register the service
async def set_water_setpoint(call: ServiceCall) -> None:
"""Set the water setpoint of the heat pump."""
temperature = call.data.get(ATTR_TEMPERATURE)
duration = call.data.get(ATTR_DURATION, "forever")
await coordinator.set_water_setpoint(temperature, duration)
hass.services.async_register(
DOMAIN,
SERVICE_SET_WATER_SETPOINT,
set_water_setpoint,
schema=SET_WATER_SETPOINT_SCHEMA,
)
await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS) await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
return True return True
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Unload a config entry."""
unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
if unload_ok:
hass.data[DOMAIN].pop(entry.entry_id)
return unload_ok
class HeatPumpDataCoordinator(DataUpdateCoordinator): class HeatPumpDataCoordinator(DataUpdateCoordinator):
"""Class to manage fetching heat pump data.""" """Class to manage fetching heat pump data."""
@@ -77,6 +103,9 @@ class HeatPumpDataCoordinator(DataUpdateCoordinator):
update_interval=update_interval, update_interval=update_interval,
) )
self.url = url self.url = url
# Extract the base URL by removing the last path segment
parts = url.split('/')
self.base_url = '/'.join(parts[:-1])
async def _async_update_data(self): async def _async_update_data(self):
"""Fetch data from heat pump.""" """Fetch data from heat pump."""
@@ -128,4 +157,85 @@ class HeatPumpDataCoordinator(DataUpdateCoordinator):
"alarm_label": status.get("alarm", {}).get("label", ""), "alarm_label": status.get("alarm", {}).get("label", ""),
} }
except aiohttp.ClientError as err: except aiohttp.ClientError as err:
raise UpdateFailed(f"Error communicating with heat pump: {err}") raise UpdateFailed(f"Error communicating with heat pump: {err}")
async def set_water_setpoint(self, temperature: float, duration: str = "forever") -> bool:
"""Set water setpoint temperature."""
try:
setpoint_url = f"{self.base_url}/index.php?Action=SetParameter"
# Prepare form data
form_data = {
"Key": "watersetpoint",
"Value": str(temperature),
"manual": duration
}
_LOGGER.debug(f"Setting watersetpoint to {temperature} with duration {duration}")
async with aiohttp.ClientSession() as session:
async with session.post(
setpoint_url,
data=form_data,
headers={"Content-Type": "application/x-www-form-urlencoded"}
) as response:
if response.status != 200:
_LOGGER.error(f"Failed to set water setpoint: {response.status}")
return False
_LOGGER.info(f"Successfully set water setpoint to {temperature}")
# Force an immediate data refresh
await self.async_request_refresh()
return True
except Exception as err:
_LOGGER.error(f"Error setting water setpoint: {err}")
return False
async def set_dhw_setpoint(self, temperature: float, duration: str = "forever") -> bool:
"""Set water setpoint temperature."""
try:
setpoint_url = f"{self.base_url}/index.php?Action=SetParameter"
# Prepare form data
form_data = {
"Key": "dhwsetpoint",
"Value": str(temperature),
"manual": duration
}
_LOGGER.debug(f"Setting dhwsetpoint to {temperature} with duration {duration}")
async with aiohttp.ClientSession() as session:
async with session.post(
setpoint_url,
data=form_data,
headers={"Content-Type": "application/x-www-form-urlencoded"}
) as response:
if response.status != 200:
_LOGGER.error(f"Failed to set dhw setpoint: {response.status}")
return False
_LOGGER.info(f"Successfully set dhw setpoint to {temperature}")
# Force an immediate data refresh
await self.async_request_refresh()
return True
except Exception as err:
_LOGGER.error(f"Error setting dhw setpoint: {err}")
return False
class HeatPumpEntity(CoordinatorEntity):
"""Base class for heat pump entities."""
def __init__(self, coordinator, sensor_type=None):
"""Initialize the entity."""
super().__init__(coordinator)
self.sensor_type = sensor_type
@property
def device_info(self):
"""Return device information."""
return {
"identifiers": {(DOMAIN, "heat_pump")},
"name": "Heat Pump",
"manufacturer": "RDZ",
"model": "PDC",
"sw_version": self.coordinator.data.get("software_version", "Unknown"),
}
+5 -7
View File
@@ -1,13 +1,12 @@
""" """
Place this code in custom_components/heat_pump_monitor/binary_sensor.py Place this code in custom_components/rdz_innova_heatpump/binary_sensor.py
""" """
from homeassistant.components.binary_sensor import ( from homeassistant.components.binary_sensor import (
BinarySensorEntity, BinarySensorEntity,
BinarySensorDeviceClass, BinarySensorDeviceClass,
) )
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from . import DOMAIN, HeatPumpDataCoordinator from . import DOMAIN, HeatPumpEntity
async def async_setup_entry(hass, entry, async_add_entities): async def async_setup_entry(hass, entry, async_add_entities):
"""Set up binary sensors.""" """Set up binary sensors."""
@@ -27,13 +26,12 @@ async def async_setup_entry(hass, entry, async_add_entities):
] ]
async_add_entities(entities) async_add_entities(entities)
class HeatPumpOperatingBinarySensor(CoordinatorEntity, BinarySensorEntity): class HeatPumpOperatingBinarySensor(HeatPumpEntity, BinarySensorEntity):
"""Binary sensor for heat pump operation states.""" """Binary sensor for heat pump operation states."""
def __init__(self, coordinator, sensor_type, name, device_class): def __init__(self, coordinator, sensor_type, name, device_class):
"""Initialize the binary sensor.""" """Initialize the binary sensor."""
super().__init__(coordinator) super().__init__(coordinator, sensor_type)
self.sensor_type = sensor_type
self._attr_name = f"Heat Pump {name}" self._attr_name = f"Heat Pump {name}"
self._attr_unique_id = f"{DOMAIN}_{sensor_type}" self._attr_unique_id = f"{DOMAIN}_{sensor_type}"
self._attr_device_class = device_class self._attr_device_class = device_class
@@ -41,4 +39,4 @@ class HeatPumpOperatingBinarySensor(CoordinatorEntity, BinarySensorEntity):
@property @property
def is_on(self): def is_on(self):
"""Return true if the binary sensor is on.""" """Return true if the binary sensor is on."""
return self.coordinator.data.get(self.sensor_type, False) return self.coordinator.data.get(self.sensor_type, False)
+92
View File
@@ -0,0 +1,92 @@
"""
Place this code in custom_components/rdz_innova_heatpump/climate.py
"""
import logging
from typing import Any, Dict, List, Optional
from homeassistant.components.climate import (
ClimateEntity,
ClimateEntityFeature,
HVACMode,
HVACAction,
)
from homeassistant.const import (
ATTR_TEMPERATURE,
UnitOfTemperature,
)
from . import DOMAIN, HeatPumpEntity
_LOGGER = logging.getLogger(__name__)
# Define available HVAC modes based on heat pump capabilities
HVAC_MODES = [HVACMode.HEAT, HVACMode.COOL, HVACMode.OFF]
async def async_setup_entry(hass, entry, async_add_entities):
"""Set up the heat pump climate."""
coordinator = hass.data[DOMAIN][entry.entry_id]
async_add_entities([HeatPumpClimate(coordinator)])
class HeatPumpClimate(HeatPumpEntity, ClimateEntity):
"""Heat pump climate entity."""
def __init__(self, coordinator):
"""Initialize the heat pump climate entity."""
super().__init__(coordinator)
self._attr_name = "Heat Pump Water Temperature"
self._attr_unique_id = f"{DOMAIN}_climate"
self._attr_temperature_unit = UnitOfTemperature.CELSIUS
self._attr_hvac_modes = HVAC_MODES
self._attr_supported_features = ClimateEntityFeature.TARGET_TEMPERATURE
self._attr_min_temp = 35
self._attr_max_temp = 60
self._attr_target_temperature_step = 0.5
@property
def current_temperature(self) -> Optional[float]:
"""Return the current temperature."""
# Use T1 (inflow temperature) as the current temperature
return self.coordinator.data.get("water_temp_t1")
@property
def target_temperature(self) -> Optional[float]:
"""Return the target temperature."""
return self.coordinator.data.get("water_setpoint")
@property
def hvac_mode(self) -> str:
"""Return the current HVAC mode."""
if self.coordinator.data.get("is_standby", False):
return HVACMode.OFF
elif self.coordinator.data.get("is_cooling", False):
return HVACMode.COOL
else:
return HVACMode.HEAT
@property
def hvac_action(self) -> Optional[str]:
"""Return the current HVAC action."""
if self.coordinator.data.get("is_standby", False):
return HVACAction.OFF
elif self.coordinator.data.get("is_cooling", False) and self.coordinator.data.get("is_working", False):
return HVACAction.COOLING
elif self.coordinator.data.get("is_heating", False) and self.coordinator.data.get("is_working", False):
return HVACAction.HEATING
else:
return HVACAction.IDLE
async def async_set_temperature(self, **kwargs) -> None:
"""Set new target temperature."""
if ATTR_TEMPERATURE not in kwargs:
return
temperature = kwargs[ATTR_TEMPERATURE]
await self.coordinator.set_water_setpoint(temperature)
self.async_write_ha_state()
async def async_set_hvac_mode(self, hvac_mode: str) -> None:
"""Set HVAC mode."""
# Note: This would require additional endpoints to control the heat pump mode
# For now, we'll just log that this functionality isn't implemented
_LOGGER.warning("Setting HVAC mode is not currently supported by this integration")
# In the future, you could implement this if the heat pump API supports mode changes
+1 -1
View File
@@ -5,7 +5,7 @@ from homeassistant import config_entries
from homeassistant.const import CONF_URL, CONF_SCAN_INTERVAL from homeassistant.const import CONF_URL, CONF_SCAN_INTERVAL
import voluptuous as vol import voluptuous as vol
class HeatPumpMonitorConfigFlow(config_entries.ConfigFlow, domain="ha_rdz_pdc_config"): class HeatPumpMonitorConfigFlow(config_entries.ConfigFlow, domain="rdz_innova_heatpump"):
"""Handle a config flow.""" """Handle a config flow."""
VERSION = 1 VERSION = 1
@@ -1,10 +1,10 @@
{ {
"domain": "ha_rdz_pdc_config", "domain": "rdz_innova_heatpump",
"name": "Heat Pump Monitor", "name": "Heat Pump Monitor",
"documentation": "https://github.com/your_username/heat_pump_monitor", "documentation": "https://github.com/costea32/rdz_innova_heatpump",
"dependencies": [], "dependencies": [],
"codeowners": ["@your_username"], "codeowners": ["@costea32"],
"requirements": [], "requirements": [],
"config_flow": true, "config_flow": true,
"iot_class": "local_polling", "iot_class": "local_polling",
+11 -16
View File
@@ -1,5 +1,5 @@
""" """
Place this code in custom_components/heat_pump_monitor/sensor.py Place this code in custom_components/rdz_innova_heatpump/sensor.py
""" """
from homeassistant.components.sensor import ( from homeassistant.components.sensor import (
SensorEntity, SensorEntity,
@@ -7,9 +7,8 @@ from homeassistant.components.sensor import (
SensorStateClass, SensorStateClass,
) )
from homeassistant.const import UnitOfTemperature, UnitOfTime from homeassistant.const import UnitOfTemperature, UnitOfTime
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from . import DOMAIN, HeatPumpDataCoordinator from . import DOMAIN, HeatPumpEntity
async def async_setup_entry(hass, entry, async_add_entities): async def async_setup_entry(hass, entry, async_add_entities):
"""Set up sensors.""" """Set up sensors."""
@@ -31,13 +30,12 @@ async def async_setup_entry(hass, entry, async_add_entities):
] ]
async_add_entities(entities) async_add_entities(entities)
class HeatPumpTemperatureSensor(CoordinatorEntity, SensorEntity): class HeatPumpTemperatureSensor(HeatPumpEntity, SensorEntity):
"""Temperature sensor for heat pump.""" """Temperature sensor for heat pump."""
def __init__(self, coordinator, sensor_type, name): def __init__(self, coordinator, sensor_type, name):
"""Initialize the sensor.""" """Initialize the sensor."""
super().__init__(coordinator) super().__init__(coordinator, sensor_type)
self.sensor_type = sensor_type
self._attr_name = f"Heat Pump {name}" self._attr_name = f"Heat Pump {name}"
self._attr_unique_id = f"{DOMAIN}_{sensor_type}" self._attr_unique_id = f"{DOMAIN}_{sensor_type}"
self._attr_device_class = SensorDeviceClass.TEMPERATURE self._attr_device_class = SensorDeviceClass.TEMPERATURE
@@ -49,13 +47,12 @@ class HeatPumpTemperatureSensor(CoordinatorEntity, SensorEntity):
"""Return the state of the sensor.""" """Return the state of the sensor."""
return self.coordinator.data.get(self.sensor_type) return self.coordinator.data.get(self.sensor_type)
class HeatPumpTimeSensor(CoordinatorEntity, SensorEntity): class HeatPumpTimeSensor(HeatPumpEntity, SensorEntity):
"""Time sensor for heat pump operation hours.""" """Time sensor for heat pump operation hours."""
def __init__(self, coordinator, sensor_type, name): def __init__(self, coordinator, sensor_type, name):
"""Initialize the sensor.""" """Initialize the sensor."""
super().__init__(coordinator) super().__init__(coordinator, sensor_type)
self.sensor_type = sensor_type
self._attr_name = f"Heat Pump {name}" self._attr_name = f"Heat Pump {name}"
self._attr_unique_id = f"{DOMAIN}_{sensor_type}" self._attr_unique_id = f"{DOMAIN}_{sensor_type}"
self._attr_device_class = SensorDeviceClass.DURATION self._attr_device_class = SensorDeviceClass.DURATION
@@ -65,21 +62,19 @@ class HeatPumpTimeSensor(CoordinatorEntity, SensorEntity):
@property @property
def native_value(self): def native_value(self):
"""Return the state of the sensor.""" """Return the state of the sensor."""
# Convert the value from hours to seconds for Home Assistant # Return the hours value directly
hours = self.coordinator.data.get(self.sensor_type, 0) return self.coordinator.data.get(self.sensor_type, 0)
return hours
class HeatPumpVersionSensor(CoordinatorEntity, SensorEntity): class HeatPumpVersionSensor(HeatPumpEntity, SensorEntity):
"""Software version sensor for heat pump.""" """Software version sensor for heat pump."""
def __init__(self, coordinator, sensor_type, name): def __init__(self, coordinator, sensor_type, name):
"""Initialize the sensor.""" """Initialize the sensor."""
super().__init__(coordinator) super().__init__(coordinator, sensor_type)
self.sensor_type = sensor_type
self._attr_name = f"Heat Pump {name}" self._attr_name = f"Heat Pump {name}"
self._attr_unique_id = f"{DOMAIN}_{sensor_type}" self._attr_unique_id = f"{DOMAIN}_{sensor_type}"
@property @property
def native_value(self): def native_value(self):
"""Return the state of the sensor.""" """Return the state of the sensor."""
return self.coordinator.data.get(self.sensor_type) return self.coordinator.data.get(self.sensor_type)
+53
View File
@@ -0,0 +1,53 @@
"""
Place this code in custom_components/rdz_innova_heatpump/water_heater.py
"""
from homeassistant.components.water_heater import (
WaterHeaterEntity,
WaterHeaterEntityFeature,
STATE_OFF,
STATE_ON,
)
from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
from . import DOMAIN, HeatPumpEntity
async def async_setup_entry(hass, entry, async_add_entities):
"""Set up water heater."""
coordinator = hass.data[DOMAIN][entry.entry_id]
async_add_entities([HeatPumpWaterHeater(coordinator)])
class HeatPumpWaterHeater(HeatPumpEntity, WaterHeaterEntity):
"""Heat pump water heater entity."""
def __init__(self, coordinator):
"""Initialize the water heater entity."""
super().__init__(coordinator)
self._attr_name = "Heat Pump DHW"
self._attr_unique_id = f"{DOMAIN}_water_heater"
self._attr_temperature_unit = UnitOfTemperature.CELSIUS
self._attr_min_temp = 35
self._attr_max_temp = 60
self._attr_target_temperature_step = 0.5
self._attr_supported_features = WaterHeaterEntityFeature.TARGET_TEMPERATURE
@property
def current_temperature(self):
"""Return the current temperature."""
return self.coordinator.data.get("dhw_temp_t3")
@property
def target_temperature(self):
"""Return the target temperature."""
return self.coordinator.data.get("dhw_setpoint")
@property
def state(self):
"""Return the current state."""
if self.coordinator.data.get("is_dhw", False):
return STATE_ON
return STATE_OFF
async def async_set_temperature(self, **kwargs):
"""Set new target temperature."""
temperature = kwargs.get(ATTR_TEMPERATURE)
await self.coordinator.set_dhw_setpoint(temperature)
View File
+124
View File
@@ -0,0 +1,124 @@
views:
- title: Home
sections:
- type: grid
cards:
- show_name: true
show_icon: true
type: button
tap_action:
action: none
entity: binary_sensor.heat_pump_alarm
icon: mdi:alarm-light
show_state: true
- show_name: true
show_icon: true
type: button
tap_action:
action: none
entity: binary_sensor.heat_pump_heating
- show_name: true
show_icon: true
type: button
tap_action:
action: toggle
entity: binary_sensor.heat_pump_cooling
icon: mdi:snowflake
- show_name: true
show_icon: true
type: button
tap_action:
action: toggle
entity: binary_sensor.heat_pump_sce
icon: mdi:water-pump
- show_name: true
show_icon: true
type: button
entity: binary_sensor.heat_pump_standby
column_span: 2
- type: grid
cards:
- type: thermostat
entity: climate.boiler_temperature
show_current_as_primary: true
features:
- style: icons
type: climate-preset-modes
preset_modes:
- comfort
- eco
- sleep
- activity
grid_options:
columns: 6
rows: 4
- type: thermostat
entity: climate.heat_pump_water_temperature
features:
- type: climate-hvac-modes
hvac_modes:
- heat
- cool
- 'off'
grid_options:
columns: 6
rows: 4
- type: grid
cards:
- title: History
type: history-graph
hours_to_show: 24
entities:
- entity: sensor.heat_pump_auxiliary_heater_2
- entity: binary_sensor.heat_pump_auxiliary_heater
- entity: binary_sensor.heat_pump_dhw_mode
- entity: sensor.heat_pump_dhw_setpoint
- entity: sensor.heat_pump_dhw_temperature_t3
- entity: sensor.heat_pump_water_temperature_t1
- entity: sensor.heat_pump_outdoor_temperature_t4
- entity: sensor.heat_pump_system_setpoint_temperature
- entity: binary_sensor.heat_pump_pump
- entity: sensor.heat_pump_water_setpoint
- entity: binary_sensor.heat_pump_working
- entity: sensor.heat_pump_inflow_temperature_t1
- entity: sensor.heat_pump_outflow_temperature_t2
- entity: binary_sensor.heat_pump_water_pump
- entity: sensor.heat_pump_system_setpoint_temperature
- entity: sensor.heat_pump_inlet_setpoint_temperature
- entity: sensor.t_puffer_temperature
- entity: switch.puffer_heater_relay_switch_0
- entity: sensor.deye_12_external_power
- entity: switch.boiler_heater_relay_switch_0
grid_options:
columns: 48
rows: auto
column_span: 4
- type: grid
cards:
- type: heading
heading: New section
- type: custom:scheduler-card
include:
- climate
exclude: []
grid_options:
columns: 12
rows: 4
cards: []
- type: sections
max_columns: 4
title: Schedules
path: schedules
sections:
- type: grid
cards:
- type: heading
heading: New section
- type: tile
entity: schedule.bath_water_schedule
features_position: bottom
vertical: true
show_entity_picture: false
state_content:
- state
- next_event
+49
View File
@@ -0,0 +1,49 @@
{
"name": "ludeeus/integration_blueprint",
"image": "mcr.microsoft.com/devcontainers/python:3.13",
"postCreateCommand": "scripts/setup",
"forwardPorts": [
8123
],
"portsAttributes": {
"8123": {
"label": "Home Assistant",
"onAutoForward": "notify"
}
},
"customizations": {
"vscode": {
"extensions": [
"charliermarsh.ruff",
"github.vscode-pull-request-github",
"ms-python.python",
"ms-python.vscode-pylance",
"ryanluker.vscode-coverage-gutters"
],
"settings": {
"files.eol": "\n",
"editor.tabSize": 4,
"editor.formatOnPaste": true,
"editor.formatOnSave": true,
"editor.formatOnType": false,
"files.trimTrailingWhitespace": true,
"python.analysis.typeCheckingMode": "basic",
"python.analysis.autoImportCompletions": true,
"python.defaultInterpreterPath": "/usr/local/bin/python",
"[python]": {
"editor.defaultFormatter": "charliermarsh.ruff"
}
}
}
},
"remoteUser": "vscode",
"features": {
"ghcr.io/devcontainers-extra/features/apt-packages:1": {
"packages": [
"ffmpeg",
"libturbojpeg0",
"libpcap-dev"
]
}
}
}
+30
View File
@@ -0,0 +1,30 @@
title: RDZ PDC Heat Pump Monitor
description: Home Assistant custom integration for RDZ PDC heat pumps
remote_theme: pages-themes/cayman@v0.2.0
plugins:
- jekyll-remote-theme
# Navigation
header_pages:
- index.md
- installation.md
- configuration.md
- dashboard.md
- troubleshooting.md
- api.md
# Build settings
markdown: kramdown
highlighter: rouge
# GitHub repository info
github:
is_project_page: true
repository_url: https://github.com/your-username/rdz_innova_heatpump
# Defaults
defaults:
- scope:
path: ""
values:
layout: default
+275
View File
@@ -0,0 +1,275 @@
---
layout: default
title: API Reference
nav_order: 6
---
# API Reference
## Heat Pump Web API
The integration communicates with the heat pump's embedded web server.
### Get Status
Retrieves current heat pump status and sensor readings.
**Endpoint:**
```
GET /installedplugin/com.innova.pdc/<VERSION>/server/index.php?Action=GetStatus
```
**Response:**
```json
{
"sw": { "V": "3.0.49" },
"success": true,
"model": "RDZ",
"RESULT": {
"TSLastUpdate": 1759138628,
"info": {
"datetime": "29/09/2025 12:37"
},
"status": {
"ISP": "34.3 °C",
"SSP": 47.0,
"watert1": 32.1,
"watert2": 32.0,
"dhwt3": 46.8,
"t4": 9.6,
"watersetpoint": 43.0,
"dhwsetpoint": 47.0,
"heating": true,
"cooling": false,
"pwr": false,
"san": false,
"pump": true,
"res": false,
"standby": false,
"sce": true,
"alarm": {
"status": false,
"type": "",
"label": ""
},
"worktime_pdc": 11614,
"worktime_res": 593
}
}
}
```
### Status Fields
| Field | Type | Description |
|-------|------|-------------|
| `ISP` | string | Inlet Setpoint (e.g., "34.3 °C") |
| `SSP` | float | System Setpoint |
| `watert1` | float | Inflow water temperature |
| `watert2` | float | Outflow water temperature |
| `dhwt3` | float | Domestic hot water temperature |
| `t4` | float | Outdoor temperature |
| `watersetpoint` | float | Water temperature setpoint |
| `dhwsetpoint` | float | DHW temperature setpoint |
| `heating` | bool | Heating mode active |
| `cooling` | bool | Cooling mode active |
| `pwr` | bool | Compressor running |
| `san` | bool | DHW mode active |
| `pump` | bool | Circulation pump active |
| `res` | bool | Auxiliary heater active |
| `standby` | bool | Standby mode |
| `sce` | bool | Smart Consumer Electronics |
| `alarm.status` | bool | Alarm active |
| `alarm.type` | string | Alarm type code |
| `alarm.label` | string | Alarm description |
| `worktime_pdc` | int | Compressor runtime (hours) |
| `worktime_res` | int | Aux heater runtime (hours) |
### Set Parameter
Sets a heat pump parameter (temperature setpoint).
**Endpoint:**
```
POST /installedplugin/com.innova.pdc/<VERSION>/server/index.php?Action=SetParameter
```
**Content-Type:** `application/x-www-form-urlencoded`
**Parameters:**
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `Key` | string | Yes | Parameter name: `watersetpoint` or `dhwsetpoint` |
| `Value` | string | Yes | Temperature value |
| `manual` | string | Yes | Duration: `forever` or time-based |
**Example:**
```bash
curl -X POST "http://192.168.1.100/installedplugin/com.innova.pdc/2.0.10/server/index.php?Action=SetParameter" \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "Key=watersetpoint&Value=45&manual=forever"
```
**Response:** HTTP 200 on success
---
## Home Assistant Services
### rdz_innova_heatpump.set_water_setpoint
Manually set the heating water temperature setpoint.
**Service Data:**
| Attribute | Type | Required | Description |
|-----------|------|----------|-------------|
| `temperature` | float | Yes | Target temperature (35-60°C) |
| `duration` | string | No | Duration: "forever" (default) or time-based |
**Example YAML:**
```yaml
service: rdz_innova_heatpump.set_water_setpoint
data:
temperature: 45
duration: forever
```
**Example Automation:**
```yaml
automation:
- alias: "Set water temperature on schedule"
trigger:
- platform: time
at: "06:00:00"
action:
- service: rdz_innova_heatpump.set_water_setpoint
data:
temperature: 45
duration: forever
```
---
## Entities
### Climate Entity
**Entity ID:** `climate.heat_pump_water_temperature`
**Attributes:**
| Attribute | Description |
|-----------|-------------|
| `current_temperature` | Current water temperature (T1) |
| `temperature` | Target temperature setpoint |
| `hvac_mode` | Current mode: `heat`, `cool`, `off` |
| `hvac_action` | Current action: `heating`, `cooling`, `idle`, `off` |
| `min_temp` | Minimum setpoint (35°C) |
| `max_temp` | Maximum setpoint (60°C) |
| `target_temp_step` | Temperature step (0.5°C) |
**Supported Features:**
- `TARGET_TEMPERATURE`
**HVAC Modes:**
- `heat` - Heating mode
- `cool` - Cooling mode
- `off` - Standby
### Water Heater Entity
**Entity ID:** `water_heater.heat_pump_dhw`
**Attributes:**
| Attribute | Description |
|-----------|-------------|
| `current_temperature` | Current DHW temperature (T3) |
| `temperature` | Target DHW setpoint |
| `operation_mode` | `on` when DHW active, `off` otherwise |
| `min_temp` | Minimum setpoint (35°C) |
| `max_temp` | Maximum setpoint (60°C) |
### Sensor Entities
| Entity ID | Unit | Description |
|-----------|------|-------------|
| `sensor.heat_pump_inlet_setpoint_temperature` | °C | ISP value |
| `sensor.heat_pump_system_setpoint_temperature` | °C | SSP value |
| `sensor.heat_pump_water_temperature_t1` | °C | Inflow temperature |
| `sensor.heat_pump_outflow_temperature_t2` | °C | Outflow temperature |
| `sensor.heat_pump_dhw_temperature_t3` | °C | DHW temperature |
| `sensor.heat_pump_outdoor_temperature_t4` | °C | Outdoor temperature |
| `sensor.heat_pump_water_setpoint` | °C | Water setpoint |
| `sensor.heat_pump_dhw_setpoint` | °C | DHW setpoint |
| `sensor.heat_pump_runtime` | h | Compressor hours |
| `sensor.heat_pump_auxiliary_heater_runtime` | h | Aux heater hours |
| `sensor.heat_pump_software_version` | - | Firmware version |
### Binary Sensor Entities
| Entity ID | Device Class | Description |
|-----------|--------------|-------------|
| `binary_sensor.heat_pump_heating` | heat | Heating mode |
| `binary_sensor.heat_pump_cooling` | cold | Cooling mode |
| `binary_sensor.heat_pump_working` | running | Compressor active |
| `binary_sensor.heat_pump_dhw_mode` | running | DHW mode |
| `binary_sensor.heat_pump_water_pump` | running | Pump active |
| `binary_sensor.heat_pump_auxiliary_heater` | heat | Aux heater active |
| `binary_sensor.heat_pump_standby` | power | Standby mode |
| `binary_sensor.heat_pump_disabled_prod` | power | Production disabled |
| `binary_sensor.heat_pump_sce` | power | SCE active |
| `binary_sensor.heat_pump_alarm` | problem | Alarm active |
---
## Internal Data Structure
The coordinator maintains this internal data structure:
```python
{
"software_version": "3.0.49",
"last_update": 1759138628,
"datetime": "29/09/2025 12:37",
# Temperatures
"inlet_setpoint_temp": 34.3,
"system_setpoint_temp": 47.0,
"water_temp_t1": 32.1,
"water_temp_t2": 32.0,
"dhw_temp_t3": 46.8,
"outdoor_temp_t4": 9.6,
"water_setpoint": 43.0,
"dhw_setpoint": 47.0,
"aux_heater": 0,
# States
"is_heating": True,
"is_cooling": False,
"is_working": False,
"is_dhw": False,
"is_pump_active": True,
"is_aux_heater": False,
"is_standby": False,
"disabled_prod": False,
"sce": True,
# Runtimes
"worktime_pdc": 11614,
"worktime_res": 593,
# Alarms
"has_alarm": False,
"alarm_type": "",
"alarm_label": ""
}
```
Access in custom code:
```python
coordinator = hass.data[DOMAIN][entry.entry_id]
temp = coordinator.data.get("water_temp_t1")
```
View File
+49
View File
@@ -0,0 +1,49 @@
# Image Placeholders
Add screenshots to this folder. The documentation references the following images:
## Home Page
- `dashboard-overview.png` - Main dashboard overview screenshot
## Installation Page
- `file-structure.png` - File explorer showing correct directory structure
- `restart-ha.png` - Home Assistant restart screen
- `search-integration.png` - Integration search dialog
- `add-integration.png` - Add integration confirmation
- `device-overview.png` - Device page showing all entities
## Configuration Page
- `devtools-network.png` - Browser DevTools Network tab showing API request
- `json-response.png` - Example JSON response in browser
- `config-url.png` - Configuration wizard URL input step
- `config-interval.png` - Configuration wizard interval input step
- `config-confirm.png` - Configuration confirmation screen
- `reconfigure.png` - Integration options/reconfigure screen
- `rename-entity.png` - Entity customization dialog
## Dashboard Page
- `dashboard-full.png` - Complete dashboard view
- `dashboard-import.png` - Raw configuration editor for importing
- `dashboard-status-buttons.png` - Status button row close-up
- `dashboard-thermostats.png` - Thermostat cards close-up
- `dashboard-history.png` - History graph close-up
- `dashboard-scheduler.png` - Scheduler card (if installed)
- `dashboard-gauge.png` - Example gauge card
- `dashboard-mobile.png` - Mobile view of dashboard
## Troubleshooting Page
- `troubleshoot-logs.png` - Home Assistant logs showing errors
- `troubleshoot-missing-sensors.png` - Entities showing unavailable
- `troubleshoot-set-temp.png` - Logs when setting temperature
## Recommended Screenshot Dimensions
- Full page screenshots: 1200x800 px
- Close-up/detail shots: 600x400 px
- Mobile screenshots: 375x667 px (iPhone size)
## Tips for Good Screenshots
1. Use a clean Home Assistant installation or demo mode
2. Hide personal information (IP addresses, names)
3. Use consistent theme (light or dark)
4. Crop to show relevant areas
5. Add annotations if helpful (arrows, highlights)
+124
View File
@@ -0,0 +1,124 @@
---
layout: default
title: Configuration
nav_order: 3
---
# Configuration
## Finding Your Heat Pump URL
The integration requires the URL to your heat pump's status API. The format is typically:
```
http://<HEAT_PUMP_IP>/installedplugin/com.innova.pdc/<VERSION>/server/index.php?Action=GetStatus
```
### Method 1: Browser Developer Tools
1. Access your heat pump's web interface in a browser
2. Open browser developer tools (F12)
3. Navigate to the **Network** tab
4. Refresh the page or navigate the heat pump interface
5. Look for requests to `index.php?Action=GetStatus`
6. Copy the full URL
![Finding URL in DevTools](assets/images/devtools-network.png)
*Use browser developer tools to find the correct API URL*
### Method 2: Common URL Patterns
Try these common URL patterns (replace IP with your heat pump's IP):
```
http://192.168.1.100/installedplugin/com.innova.pdc/2.0.10/server/index.php?Action=GetStatus
http://192.168.1.100/installedplugin/com.innova.pdc/3.0.49/server/index.php?Action=GetStatus
```
### Verify Your URL
Open the URL in a browser. You should see a JSON response like:
```json
{
"success": true,
"sw": { "V": "3.0.49" },
"RESULT": {
"status": {
"watert1": 32.1,
"watert2": 32.0,
"heating": true,
...
}
}
}
```
![JSON Response](assets/images/json-response.png)
*Expected JSON response when accessing the URL*
## Configuration Wizard
### Step 1: Enter URL
When adding the integration, enter your heat pump URL:
![Enter URL](assets/images/config-url.png)
*Enter the heat pump status URL*
### Step 2: Set Update Interval
Optionally configure the update interval (default: 3 seconds):
| Setting | Description | Recommended |
|---------|-------------|-------------|
| 1-2 seconds | Very frequent updates | High network load |
| 3 seconds | Default, good balance | Recommended |
| 5-10 seconds | Less frequent | Low network load |
![Update Interval](assets/images/config-interval.png)
*Configure the polling interval*
### Step 3: Confirm Configuration
Review and confirm your settings:
![Confirm Config](assets/images/config-confirm.png)
*Review configuration before completing setup*
## Configuration Options
After initial setup, you can modify options:
1. Go to **Settings** > **Devices & Services**
2. Find "Heat Pump Monitor"
3. Click **Configure**
![Reconfigure](assets/images/reconfigure.png)
*Access configuration options after setup*
## Entity Customization
After setup, you may want to customize entities:
### Rename Entities
1. Go to **Settings** > **Devices & Services**
2. Click on the Heat Pump device
3. Click on an entity
4. Change the name as desired
![Rename Entity](assets/images/rename-entity.png)
*Customize entity names*
### Hide Unused Entities
If some sensors don't apply to your setup:
1. Click on the entity
2. Toggle "Enable" off
## Next Steps
- [Set up the dashboard](dashboard.md)
- [Troubleshoot issues](troubleshooting.md)
+187
View File
@@ -0,0 +1,187 @@
---
layout: default
title: Dashboard
nav_order: 4
---
# Dashboard Setup
A pre-configured dashboard is included with the integration to help you get started quickly.
## Dashboard Overview
![Dashboard Full View](assets/images/dashboard-full.png)
*Complete dashboard view with all components*
The dashboard includes:
- Status indicator buttons
- Thermostat cards for temperature control
- History graphs for monitoring
- Scheduler integration (optional)
## Installing the Dashboard
### Method 1: Import YAML
1. Go to **Settings** > **Dashboards**
2. Click **+ Add Dashboard**
3. Choose "New dashboard from scratch"
4. Give it a name (e.g., "Heat Pump")
5. Open the dashboard and click the three dots menu
6. Select **Edit Dashboard**
7. Click the three dots again and select **Raw configuration editor**
8. Paste the contents of `dashboards/dash.yaml`
9. Click **Save**
![Import Dashboard](assets/images/dashboard-import.png)
*Import dashboard using raw configuration editor*
### Method 2: Add Cards Manually
You can also add individual cards to an existing dashboard.
## Dashboard Components
### Status Buttons
![Status Buttons](assets/images/dashboard-status-buttons.png)
*Status indicator buttons*
The top row shows quick status indicators:
| Button | Entity | Description |
|--------|--------|-------------|
| Alarm | `binary_sensor.heat_pump_alarm` | Shows alarm status |
| Heating | `binary_sensor.heat_pump_heating` | Heating mode active |
| Cooling | `binary_sensor.heat_pump_cooling` | Cooling mode active |
| SCE | `binary_sensor.heat_pump_sce` | Smart Consumer Electronics |
| Standby | `binary_sensor.heat_pump_standby` | Standby mode |
### Thermostat Cards
![Thermostat Cards](assets/images/dashboard-thermostats.png)
*Thermostat cards for temperature control*
Two thermostat cards provide temperature control:
#### Water Temperature Thermostat
- Entity: `climate.heat_pump_water_temperature`
- Controls heating/cooling water setpoint
- Shows current water temperature
#### DHW (Boiler) Thermostat
- Entity: `water_heater.heat_pump_dhw` or `climate.boiler_temperature`
- Controls domestic hot water setpoint
- Shows current DHW temperature
### History Graph
![History Graph](assets/images/dashboard-history.png)
*24-hour history graph showing all sensors*
The history graph tracks:
- All temperature sensors (T1, T2, T3, T4, setpoints)
- Binary status sensors (heating, cooling, pump, DHW)
- Runtime statistics
Configuration:
```yaml
type: history-graph
hours_to_show: 24
entities:
- entity: sensor.heat_pump_water_temperature_t1
- entity: sensor.heat_pump_dhw_temperature_t3
- entity: sensor.heat_pump_outdoor_temperature_t4
- entity: binary_sensor.heat_pump_heating
- entity: binary_sensor.heat_pump_working
# ... more entities
```
### Scheduler Card (Optional)
![Scheduler Card](assets/images/dashboard-scheduler.png)
*Scheduler card for automation*
The scheduler requires the [scheduler-card](https://github.com/nielsfaber/scheduler-card) custom component.
Install via HACS:
1. Open HACS
2. Search for "scheduler-card"
3. Install and restart
## Customizing the Dashboard
### Changing Time Range
Edit the history graph `hours_to_show` value:
```yaml
type: history-graph
hours_to_show: 48 # Change from 24 to 48 hours
```
### Adding More Sensors
Add entities to the history graph:
```yaml
entities:
- entity: sensor.heat_pump_water_temperature_t1
- entity: sensor.your_additional_sensor # Add new sensors
```
### Changing Layout
Adjust grid columns for different screen sizes:
```yaml
grid_options:
columns: 12 # Full width
rows: 4
```
## Mobile View
![Mobile Dashboard](assets/images/dashboard-mobile.png)
*Dashboard optimized for mobile view*
The dashboard is responsive and works on mobile devices. For better mobile experience, consider:
- Using the sections layout
- Reducing the number of history graph entities
- Using compact card styles
## Example Cards
### Simple Temperature Display
```yaml
type: entities
entities:
- entity: sensor.heat_pump_water_temperature_t1
name: Inflow Temperature
- entity: sensor.heat_pump_water_temperature_t2
name: Outflow Temperature
- entity: sensor.heat_pump_outdoor_temperature_t4
name: Outdoor Temperature
```
### Gauge Card
```yaml
type: gauge
entity: sensor.heat_pump_water_temperature_t1
min: 20
max: 60
severity:
green: 35
yellow: 45
red: 55
```
![Gauge Card](assets/images/dashboard-gauge.png)
*Temperature gauge card example*
## Next Steps
- [Troubleshoot issues](troubleshooting.md)
- [API Reference](api.md)
+74
View File
@@ -0,0 +1,74 @@
---
layout: default
title: Home
nav_order: 1
---
# RDZ PDC Heat Pump Monitor
A custom Home Assistant integration for monitoring and controlling RDZ PDC heat pumps via their embedded web interface.
![Heat Pump Dashboard Overview](assets/images/dashboard-overview.png)
*Dashboard overview showing heat pump status and controls*
## Features
- **Climate Control** - Thermostat entity for controlling heating/cooling water temperature
- **Water Heater Control** - Dedicated entity for domestic hot water (DHW) temperature control
- **Comprehensive Monitoring** - 12+ sensors for temperatures, setpoints, and runtime statistics
- **Status Indicators** - 10 binary sensors for operational states
- **Local Polling** - Direct communication with heat pump, no cloud dependency
- **Dashboard Included** - Pre-configured Lovelace dashboard YAML
## Supported Data Points
### Temperature Sensors
| Sensor | Description |
|--------|-------------|
| Inlet Setpoint (ISP) | Smart heating setpoint temperature |
| System Setpoint (SSP) | System setpoint temperature |
| Water T1 | Inflow/supply water temperature |
| Water T2 | Outflow/return water temperature |
| DHW T3 | Domestic hot water temperature |
| Outdoor T4 | External/outdoor temperature |
| Water Setpoint | Target heating water temperature |
| DHW Setpoint | Target domestic hot water temperature |
### Status Sensors
| Sensor | Description |
|--------|-------------|
| Heating | Heat pump is in heating mode |
| Cooling | Heat pump is in cooling mode |
| Working | Compressor is running |
| DHW Mode | Domestic hot water heating active |
| Water Pump | Circulation pump is active |
| Auxiliary Heater | Backup electric heater running |
| Standby | System in standby mode |
| Alarm | System alarm active |
### Runtime Statistics
| Sensor | Description |
|--------|-------------|
| Runtime (PDC) | Total compressor operating hours |
| Auxiliary Heater Runtime | Total backup heater operating hours |
## Quick Links
- [Installation Guide](installation.md)
- [Configuration](configuration.md)
- [Dashboard Setup](dashboard.md)
- [Troubleshooting](troubleshooting.md)
- [API Reference](api.md)
## Requirements
- Home Assistant 2023.1 or newer
- RDZ PDC heat pump with web interface
- Network access to heat pump from Home Assistant
## License
This project is provided as-is for personal use with RDZ PDC heat pumps.
+82
View File
@@ -0,0 +1,82 @@
---
layout: default
title: Installation
nav_order: 2
---
# Installation
## Step 1: Download the Integration
Download or clone this repository to get the integration files.
```bash
git clone https://github.com/your-username/rdz_innova_heatpump.git
```
## Step 2: Copy Integration Files
Copy the `custom_components/rdz_innova_heatpump` folder to your Home Assistant `custom_components` directory.
```
<config_directory>/
└── custom_components/
└── rdz_innova_heatpump/
├── __init__.py
├── climate.py
├── sensor.py
├── binary_sensor.py
├── water_heater.py
├── config_flow.py
├── manifest.json
└── translations/
└── en.json
```
![File Structure](assets/images/file-structure.png)
*Expected file structure after installation*
## Step 3: Restart Home Assistant
After copying the files, restart Home Assistant completely. This is required for Home Assistant to detect the new integration.
![Restart Home Assistant](assets/images/restart-ha.png)
*Restart Home Assistant from Settings > System*
## Step 4: Add Integration
1. Go to **Settings** > **Devices & Services**
2. Click **+ Add Integration** button
3. Search for "RDZ" or "Heat Pump Monitor"
![Search Integration](assets/images/search-integration.png)
*Search for the integration in the Add Integration dialog*
4. Select "Heat Pump Monitor" from the results
5. Follow the configuration wizard (see [Configuration](configuration.md))
![Add Integration](assets/images/add-integration.png)
*The integration should appear in search results*
## Step 5: Verify Installation
After configuration, you should see:
- A new device "Heat Pump" in your devices list
- Multiple entities (sensors, binary sensors, climate, water heater)
![Device Overview](assets/images/device-overview.png)
*Device overview showing all entities*
## Next Steps
- [Configure the integration](configuration.md)
- [Set up the dashboard](dashboard.md)
## Troubleshooting Installation
If the integration doesn't appear:
1. Verify files are in the correct directory
2. Check Home Assistant logs for errors
3. Ensure you restarted Home Assistant completely (not just reload)
4. See [Troubleshooting](troubleshooting.md) for more help
+202
View File
@@ -0,0 +1,202 @@
---
layout: default
title: Troubleshooting
nav_order: 5
---
# Troubleshooting
## Common Issues
### Integration Not Appearing
**Symptoms:** After copying files and restarting, "Heat Pump Monitor" doesn't appear in the integrations list.
**Solutions:**
1. Verify the folder structure is correct:
```
custom_components/
└── rdz_innova_heatpump/
├── __init__.py
├── manifest.json
└── ... other files
```
2. Check file permissions
3. Perform a full restart (not just reload)
4. Check Home Assistant logs for errors
![Check Logs](assets/images/troubleshoot-logs.png)
*Check Home Assistant logs for error messages*
### Connection Failed
**Symptoms:** "Failed to connect" error during setup.
**Solutions:**
1. Verify the URL is accessible from your HA server:
```bash
curl http://YOUR_HEAT_PUMP_IP/installedplugin/com.innova.pdc/VERSION/server/index.php?Action=GetStatus
```
2. Check network connectivity between HA and heat pump
3. Verify the URL format is correct
4. Check if heat pump web interface is responding
### Missing Sensors
**Symptoms:** Some sensors show "Unknown" or "Unavailable".
**Solutions:**
This is often due to firmware version differences. Different versions have different JSON structures.
![Missing Sensors](assets/images/troubleshoot-missing-sensors.png)
*Some sensors may show unavailable due to firmware differences*
## Firmware Version Differences
### Known Differences
| Field | v3.0.49+ | v2.3.x |
|-------|----------|--------|
| ISP (Inlet Setpoint) | `"34.3 °C"` (string with unit) | May not exist |
| SSP (System Setpoint) | Present | May not exist |
| alarm.status | `true/false` | May only have `type` field |
| res (aux heater state) | Present | May not exist |
| sce | Present | May not exist |
### Checking Your Firmware Version
1. Access your heat pump URL in a browser
2. Look for the `sw.V` field in the response:
```json
{
"sw": { "V": "3.0.49" },
...
}
```
### Adapting for Different Firmware
If your firmware has different field names, you may need to modify `__init__.py`.
**Key mappings (line ~122-158):**
```python
"inlet_setpoint_temp": float(status.get("ISP", "0").split()[0]),
"system_setpoint_temp": status.get("SSP"),
"water_temp_t1": status.get("watert1"),
"water_temp_t2": status.get("watert2"),
"dhw_temp_t3": status.get("dhwt3"),
"outdoor_temp_t4": status.get("t4"),
"water_setpoint": status.get("watersetpoint"),
"dhw_setpoint": status.get("dhwsetpoint"),
"is_heating": status.get("heating", False),
"is_working": status.get("pwr", False),
"is_cooling": status.get("cooling", False),
"is_dhw": status.get("san", False),
"is_pump_active": status.get("pump", False),
"is_aux_heater": status.get("res", False),
"is_standby": status.get("standby", False),
```
**To find correct field names:**
1. Save your heat pump's JSON response to a file
2. Compare with the sample files in `jsons/` folder
3. Adjust the field names in `__init__.py` accordingly
## Temperature Reading Issues
### Incorrect Values
**Symptoms:** Temperature shows wrong values (e.g., 0 or very high numbers).
**Solutions:**
1. Check the JSON response format for temperature fields
2. Some fields may be strings with units (e.g., `"34.3 °C"`) that need parsing
3. Verify field names match your firmware version
### ISP Field Parsing Error
The ISP field often contains a string with unit: `"34.3 °C"`
The code parses this with:
```python
float(status.get("ISP", "0").split()[0])
```
If your firmware returns a different format, adjust accordingly.
## Setting Temperature Issues
### Set Temperature Not Working
**Symptoms:** Changing temperature in thermostat card doesn't affect heat pump.
**Solutions:**
1. Check Home Assistant logs for errors
2. Verify the SetParameter endpoint is correct
3. Test manually:
```bash
curl -X POST "http://YOUR_IP/installedplugin/com.innova.pdc/VERSION/server/index.php?Action=SetParameter" \
-d "Key=watersetpoint&Value=45&manual=forever"
```
![Set Temperature Logs](assets/images/troubleshoot-set-temp.png)
*Check logs when setting temperature fails*
## Debug Logging
Enable debug logging for more information:
Add to `configuration.yaml`:
```yaml
logger:
default: info
logs:
custom_components.rdz_innova_heatpump: debug
```
Then restart Home Assistant and check logs.
## Sample JSON Files
The repository includes sample JSON responses for reference:
| File | Firmware | Description |
|------|----------|-------------|
| `jsons/og.json` | v3.0.49 | Full feature set |
| `jsons/bogdan.json` | v2.3.2 | Reduced features |
Compare your heat pump's response with these files to identify differences.
## Getting Help
### Gathering Information
When reporting issues, include:
1. Home Assistant version
2. Heat pump firmware version (from JSON `sw.V` field)
3. Full JSON response from your heat pump (sanitize IP if needed)
4. Relevant log entries
5. Steps to reproduce
### Sharing Your JSON
If you have a different firmware version, consider sharing your JSON response to help improve compatibility:
1. Save your JSON response
2. Remove any sensitive information
3. Submit as an issue or pull request
## FAQ
**Q: How often does the integration poll the heat pump?**
A: Default is every 3 seconds. Configurable during setup or in options.
**Q: Can I use this with other heat pump brands?**
A: This integration is designed for RDZ PDC heat pumps with Innova web interface. Other brands may have different APIs.
**Q: Does this work without internet?**
A: Yes, this is a local polling integration. No cloud services required.
**Q: Why are some fields missing in my version?**
A: Different firmware versions expose different data. Older versions may lack some sensors.
+173
View File
@@ -0,0 +1,173 @@
{
"sw": {
"V": "2.3.2"
},
"success": true,
"menu": [
{
"handler": "fn-homepage",
"cls": "",
"iconCls": "ion-ios-home",
"title": "HOME"
},
{
"handler": "fn-device",
"cls": "",
"iconCls": "ion-gear-a",
"root": true,
"title": "HP"
},
{
"handler": "fn-chart",
"cls": " hidden",
"iconCls": "ion-stats-bars",
"authLevel": "setup",
"title": "Charts"
},
{
"handler": "fn-events",
"cls": " hidden",
"iconCls": "ion-ios-book",
"authLevel": "setup",
"title": "Events log"
}
],
"model": "PDC RDZ",
"title": "\u003Cspan\u003EHeat pump\u003C/span\u003E",
"RESULT": {
"TSLastUpdate": 1759127624,
"status": {
"standby": false,
"dhw": true,
"pwr": false,
"san": false,
"cal": false,
"pump": false,
"auxheater": 0,
"auxheaterLabel": "Backup heater",
"auxheaterUrl": "/v/1.0.61/plugins/com.innova.pdc/gui/imgfiles/res0.png",
"ALo": 5,
"Ahi": 80,
"heating": false,
"cooling": true,
"watert1": 16.5,
"watert2": 17.6,
"dhwt3": 40.5,
"t4": 0,
"watersetpoint": 18,
"dhwValues": [14.6, 15.1, 15.6, 16.1, 16.6, 17.1, 17.6, 18.1, 18.6, 19.1, 19.6, 20.1, 20.6, 21.1, 21.6, 22.1, 22.6, 23.1, 23.6, 24.1, 24.6, 25.1, 25.6, 26.1, 26.6, 27.1, 27.6, 28.1, 28.6, 29.1, 29.6, 30.1, 30.6, 31.1, 31.6, 32.1, 32.6, 33.1, 33.6, 34.1, 34.6, 35.1, 35.6, 36.1, 36.6, 37.1, 37.6, 38.1, 38.6, 39.1, 39.6, 40.1, 40.6, 41.1, 41.6, 42.1, 42.6, 43.1, 43.6, 44.1, 44.6, 45.1, 45.6, 46.1, 46.6, 47.1, 47.6, 48.1, 48.6, 49.1, 49.6, 50.1, 50.6, 51.1, 51.6, 52.1, 52.6, 53.1, 53.6, 54.1, 54.6],
"waterValues": [
"off",
10, 10.5, 11, 11.5, 12, 12.5, 13, 13.5, 14, 14.5, 15, 15.5, 16, 16.5, 17, 17.5, 18, 18.5, 19, 19.5, 20, 20.5, 21, 21.5, 22, 22.5, 23, 23.5, 24, 24.5, 25],
"timeValues": {
"hours": [
"00",
"01",
"02",
"03",
"04",
"05",
"06",
"07",
"08",
"09",
"10",
"11",
"12",
"13",
"14",
"15",
"16",
"17",
"18",
"19",
"20",
"21",
"22",
"23"
],
"minutes": [
"00",
"01",
"02",
"03",
"04",
"05",
"06",
"07",
"08",
"09",
"10",
"11",
"12",
"13",
"14",
"15",
"16",
"17",
"18",
"19",
"20",
"21",
"22",
"23",
"24",
"25",
"26",
"27",
"28",
"29",
"30",
"31",
"32",
"33",
"34",
"35",
"36",
"37",
"38",
"39",
"40",
"41",
"42",
"43",
"44",
"45",
"46",
"47",
"48",
"49",
"50",
"51",
"52",
"53",
"54",
"55",
"56",
"57",
"58",
"59"
]
},
"legactive": false,
"dhwsetpoint": 40,
"alarm": {
"type": ""
},
"worktime_res": 1283,
"worktime_pdc": 13390,
"manualCooling": true,
"manualCoolingHfm": "forever",
"manualHeating": true,
"manualHeatingHfm": "forever",
"manualDhw": true,
"manualDhwHfm": "forever",
"hfm": 2,
"forced_ftv": 0,
"conditioning_calendar_disabled": 0
},
"info": {
"datetime": "29/09/2025 09:33"
}
}
}
+289
View File
@@ -0,0 +1,289 @@
{
"sw": {
"V": "3.0.49"
},
"success": true,
"errors": {},
"lb": {},
"RESULT": {
"TSLastUpdate": 1759138628,
"info": {
"datetime": "29/09/2025 12:37"
},
"status": {
"ALo": 5.0,
"Ahi": 80.0,
"ISP": "34.3 °C",
"SSP": 47.0,
"alarm": {
"status": false,
"type": "",
"label": ""
},
"auxheater": 0,
"auxheaterLabel": "Backup heater",
"auxheaterUrl": "/v/2.0.10/plugins/com.innova.pdc/gui/imgfiles/res0.png",
"cal": false,
"conditioning_calendar_disabled": 0,
"cooling": false,
"dhw": true,
"dhwValues": [
"30.0",
"30.5",
"31.0",
"31.5",
"32.0",
"32.5",
"33.0",
"33.5",
"34.0",
"34.5",
"35.0",
"35.5",
"36.0",
"36.5",
"37.0",
"37.5",
"38.0",
"38.5",
"39.0",
"39.5",
"40.0",
"40.5",
"41.0",
"41.5",
"42.0",
"42.5",
"43.0",
"43.5",
"44.0",
"44.5",
"45.0",
"45.5",
"46.0",
"46.5",
"47.0",
"47.5",
"48.0",
"48.5",
"49.0",
"49.5",
"50.0",
"50.5",
"51.0",
"51.5",
"52.0",
"52.5",
"53.0"
],
"dhwsetpoint": 47.0,
"dhwt3": 46.8,
"forced_ftv": 0,
"heating": true,
"hfm": 2,
"hor": -15.0,
"hoS": -15.0,
"legactive": false,
"manualCooling": true,
"manualCoolingHfm": "forever",
"manualDhw": true,
"manualDhwHfm": "forever",
"manualHeating": true,
"manualHeatingHfm": "forever",
"pump": true,
"pwr": false,
"res": false,
"san": false,
"sce": true,
"standby": false,
"t4": 9.6,
"timeValues": {
"hours": [
"00",
"01",
"02",
"03",
"04",
"05",
"06",
"07",
"08",
"09",
"10",
"11",
"12",
"13",
"14",
"15",
"16",
"17",
"18",
"19",
"20",
"21",
"22",
"23"
],
"minutes": [
"00",
"01",
"02",
"03",
"04",
"05",
"06",
"07",
"08",
"09",
"10",
"11",
"12",
"13",
"14",
"15",
"16",
"17",
"18",
"19",
"20",
"21",
"22",
"23",
"24",
"25",
"26",
"27",
"28",
"29",
"30",
"31",
"32",
"33",
"34",
"35",
"36",
"37",
"38",
"39",
"40",
"41",
"42",
"43",
"44",
"45",
"46",
"47",
"48",
"49",
"50",
"51",
"52",
"53",
"54",
"55",
"56",
"57",
"58",
"59"
]
},
"waterValues": [
"off",
"20.0",
"20.5",
"21.0",
"21.5",
"22.0",
"22.5",
"23.0",
"23.5",
"24.0",
"24.5",
"25.0",
"25.5",
"26.0",
"26.5",
"27.0",
"27.5",
"28.0",
"28.5",
"29.0",
"29.5",
"30.0",
"30.5",
"31.0",
"31.5",
"32.0",
"32.5",
"33.0",
"33.5",
"34.0",
"34.5",
"35.0",
"35.5",
"36.0",
"36.5",
"37.0",
"37.5",
"38.0",
"38.5",
"39.0",
"39.5",
"40.0",
"40.5",
"41.0",
"41.5",
"42.0",
"42.5",
"43.0",
"43.5",
"44.0",
"44.5",
"45.0"
],
"watersetpoint": 43.0,
"watert1": 32.1,
"watert2": 32.0,
"worktime_pdc": 11614,
"worktime_res": 593,
"disableProd": false
},
"title": "\u003cspan\u003eHeat pump\u003c/span\u003e",
"updateReceived": false
},
"model": "RDZ",
"menu": [
{
"cls": "",
"handler": "fn-homepage",
"iconCls": "ion-ios-home",
"title": "HOME",
"label": "HOME",
"root": false
},
{
"cls": "",
"handler": "fn-device",
"iconCls": "ion-gear-a",
"title": "HP",
"label": "HP",
"root": true
},
{
"cls": " leaf",
"handler": "fn-chart",
"iconCls": "ion-stats-bars",
"title": "Charts",
"label": "Charts",
"root": false
},
{
"cls": " leaf",
"handler": "fn-events",
"iconCls": "ion-ios-book",
"title": "Events log",
"label": "Events log",
"root": false
}
]
}
+20
View File
@@ -0,0 +1,20 @@
#!/usr/bin/env bash
set -e
cd "$(dirname "$0")/.."
# Create config dir if not present
if [[ ! -d "${PWD}/config" ]]; then
mkdir -p "${PWD}/config"
hass --config "${PWD}/config" --script ensure_config
fi
# Set the path to custom_components
## This let's us have the structure we want <root>/custom_components/integration_blueprint
## while at the same time have Home Assistant configuration inside <root>/config
## without resulting to symlinks.
export PYTHONPATH="${PYTHONPATH}:${PWD}/custom_components"
# Start Home Assistant
hass --config "${PWD}/config" --debug
Executable
+8
View File
@@ -0,0 +1,8 @@
#!/usr/bin/env bash
set -e
cd "$(dirname "$0")/.."
ruff format .
ruff check . --fix
Executable
+7
View File
@@ -0,0 +1,7 @@
#!/usr/bin/env bash
set -e
cd "$(dirname "$0")/.."
python3 -m pip install --requirement requirements.txt