Incompatible with latest version of HA

[8osman]

Hi, just want to know if you are still working with this?

It was a great little tool when it was working and it's a shame it's not anymore. completely understand that this is something that only gets done in spare time for free.

[PtolemyIV]

+1 for this.. worked great previously on my system but sadly broken by latest climate changes in HA

[8osman]

I'm guessing Alex has been too busy to keep up with this.

I've had a go at making it work with the latest version of HA. I'm no programmer so it's probably a bit buggy.

One of the issues is setting PRESET_AWAY - it switches the unit to off, however I'm not using location sensing through warmup, so the unit then updates HA to say PRESET_HOME after a few seconds.

It doesn't switch the unit on again.

I'll probably fix this in future, but busy right now. I think it probably did this before as already in my automation it set preset away - then just auto for back on.

"""Platform that offers a connection to a warmup device."""
import logging
from typing import Optional, List

from homeassistant.components.climate import PLATFORM_SCHEMA, ClimateDevice

from homeassistant.components.climate.const import (
    HVAC_MODE_AUTO,
    HVAC_MODE_HEAT,
    HVAC_MODE_OFF,
    PRESET_AWAY,
    PRESET_HOME,
    SUPPORT_PRESET_MODE,
    SUPPORT_TARGET_TEMPERATURE,
)

from homeassistant.const import (ATTR_TEMPERATURE, PRECISION_TENTHS, TEMP_CELSIUS, CONF_NAME, CONF_PASSWORD, CONF_USERNAME, CONF_ROOM)

from homeassistant.exceptions import PlatformNotReady

import homeassistant.helpers.config_validation as cv

from homeassistant.helpers.entity import async_generate_entity_id

from homeassistant.util.temperature import convert as convert_temperature


_LOGGER = logging.getLogger(__name__)

import voluptuous as vol
	
SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE
SUPPORT_HVAC_HEAT = [HVAC_MODE_HEAT, HVAC_MODE_AUTO, HVAC_MODE_OFF]
SUPPORT_PRESET = [PRESET_AWAY, PRESET_HOME]

CONF_LOCATION = 'location'
CONF_TARGET_TEMP = 'target_temp'

DEFAULT_NAME = 'warmup4ie'
DEFAULT_TARGET_TEMP = 20

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    vol.Required(CONF_USERNAME): cv.string,
    vol.Required(CONF_PASSWORD): cv.string,
    vol.Required(CONF_LOCATION): cv.string,
    vol.Required(CONF_ROOM): cv.string,
    vol.Optional(CONF_TARGET_TEMP,
                 default=DEFAULT_TARGET_TEMP): vol.Coerce(float),
})


def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up the Demo climate devices."""
    _LOGGER.info("Setting up platform for Warmup component")
    name = config.get(CONF_NAME)
    user = config.get(CONF_USERNAME)
    password = config.get(CONF_PASSWORD)
    location = config.get(CONF_LOCATION)
    room = config.get(CONF_ROOM)
    target_temp = config.get(CONF_TARGET_TEMP)

    from warmup4ie import Warmup4IEDevice
    device = Warmup4IEDevice(user, password, location, room,
                             target_temp)
    if device is None or not device.setup_finished:
        raise PlatformNotReady

    add_entities(
            [Warmup(hass, name, device)])


class Warmup(ClimateDevice):
    """Representation of a Warmup device."""

    mode_map = {'prog':HVAC_MODE_AUTO, 'fixed':HVAC_MODE_HEAT, 'off':HVAC_MODE_OFF}

    def __init__(self, hass, name, device):
        """Initialize the climate device."""
        _LOGGER.info("Setting up Warmup component")
        self._name = name
        self._hvac_mode = HVAC_MODE_AUTO
        self._hvac_list = [HVAC_MODE_HEAT, HVAC_MODE_OFF, HVAC_MODE_AUTO]
        self._unit_of_measurement = TEMP_CELSIUS
        self._on = True
        self._away_mode = False
        self._device = device
        self._support_flags = SUPPORT_FLAGS | SUPPORT_PRESET_MODE
        self._awaymodeLastState = HVAC_MODE_OFF

    @property
    def supported_features(self):
        """Return the list of supported features."""
        return SUPPORT_FLAGS
		
    @property
    def hvac_mode(self):
        """Return current HVAC mode."""
        return self._hvac_mode

    @property
    def hvac_modes(self):
        """Return available HVAC modes."""
        return self._hvac_list

    @property
    def should_poll(self):
        """Return the polling state."""
        return True

    @property
    def name(self):
        """Return the name of the climate device."""
        return self._name

    @property
    def temperature_unit(self):
        """Return the unit of measurement."""
        return self._unit_of_measurement

    @property
    def current_temperature(self):
        """Return the current temperature."""
        return self._device.get_current_temmperature()

    @property
    def target_temperature(self):
        """Return the temperature we try to reach."""
        return self._device.get_target_temmperature()

    @property
    def min_temp(self):
        """Return the minimum temperature."""
        return self._device.get_target_temperature_low()

    @property
    def max_temp(self):
        """Return the maximum temperature."""
        return self._device.get_target_temperature_high()
		
    @property
    def preset_mode(self):
        """Return the current preset mode, e.g., home, away, temp."""
        if self._away_mode:
            return PRESET_AWAY
        return PRESET_HOME

    @property
    def preset_modes(self):
        """Return a list of available preset modes."""
        return [PRESET_HOME, PRESET_AWAY]

    @property
    def is_away_mode_on(self):
        """Return if away mode is on."""
        return self._away_mode
		
    @property
    def is_on(self):
        """Return true if the device is on."""
        return self._on

    @property
    def current_hvac(self):
        """Return current operation ie. heat, auto, off."""
        return self._current_hvac_mode

    def set_temperature(self, **kwargs):
        """Set new target temperatures."""
        if kwargs.get(ATTR_TEMPERATURE) is not None:
            self._device.set_new_temperature(kwargs.get(ATTR_TEMPERATURE))

    def turn_away_mode_on(self):
        """Turn away mode on."""
        self._away_mode = True

    def turn_away_mode_off(self):
        """Turn away mode off."""
        self._away_mode = False
			
    def set_hvac_mode(self, hvac_mode):
        """Set hvac mode."""
        if hvac_mode == HVAC_MODE_HEAT:
            self._hvac_mode = HVAC_MODE_HEAT
            self._device.set_temperature_to_manual()
        elif hvac_mode == HVAC_MODE_AUTO:
            self._hvac_mode = HVAC_MODE_AUTO
            self._device.set_temperature_to_auto()
        elif hvac_mode == HVAC_MODE_OFF:
            self._hvac_mode = HVAC_MODE_OFF
            self._device.set_location_to_off()
        else:
            _LOGGER.error("Unrecognized hvac mode: %s", hvac_mode)
            return
        # Ensure we update the current operation after changing the mode
        self.schedule_update_ha_state()
		
		
		
    def set_preset_mode(self, preset_mode):
        if self._on == False: 
            return
        if preset_mode == PRESET_AWAY:
            if self._away_mode == False:
                self._awaymodeLastState = self._hvac_mode
                self._away_mode = True
                self.set_hvac_mode(HVAC_MODE_OFF)
        elif preset_mode == PRESET_HOME:
            if self._away_mode == True:
                self._away_mode = False
                self.set_hvac_mode(self._awaymodeLastState)
        else:
            _LOGGER.error("Unknown mode: %s", preset_mode)
        self.schedule_update_ha_state()
		

    def turn_on(self):
        """Turn on."""
        self._on = True
        self._device.set_temperature_to_manual()

    def turn_off(self):
        """Turn off."""
        self._on = False
        self._device.set_location_to_off()

    def update(self):
        """Fetch new state data for this device.
        This is the only method that should fetch new data for Home Assistant.
        """
        if not self._device.update_room():
            _LOGGER.error("Updating Warmup component failed")

        # set operation mode
        self._current_hvac_mode = self.mode_map.get(
            self._device.get_run_mode())

        # set whether device is in away mode
        if self._device.get_run_mode() == 'away':
            self._away_mode = True
        else:
            self._away_mode = False

        # set whether device is on/off
        if self._device.get_run_mode() == 'off':
            self._on = False
        else:
            self._on = True

        `

[8osman]

Also noted on the pypi release Alex left it at version 0.1.5

https://pypi.org/project/warmup4ie/

[PtolemyIV]

Hi 8osman - funnily enough I did exactly the same thing to make it work for myself - I have not programmed since my old C++ days so half did this for learning python etc too.

My attempt can be found at:
https://github.com/PtolemyIV/warmup4ie/blob/master/climate.py

If anyone tests it more extensively and finds obvious issues etc, please let me know since this was hacked together in a few hours
.
Alex - I am obviously not a contributor for your repository so please feel free to take this and incorporate as you see fit and I will delete from my account to avoid risk of confusion.

The one issue that I found is that, at least on the official WarmUp app, the location modes apply across all rooms - I have 3 different warmup rooms at home and obviously each climate lovelace card (I am using simple-thermostat) has its own "Heat, Auto, Off" buttons - if you click Off on one room, then all the rooms get turned off. However, if you then click Auto, only that individual room gets turned on again. So its a little odd/inconsistent.

[8osman]

haha, well done, better job than me! 👍

[PtolemyIV]

Please test it first..! Seems to work okay for me aside from location vs room issue I mention above... I'd also more generally like to have the single component call set up climate devices for all the rooms rather than needing to set up each individually (and could more readily get any device being switched back on, switch back on all the other devices)

The feature I really want on all my climate devices is a "temporary boost" button - i.e. turn on the heating for an hour in a specific room - i know you can do with scripts but both warmup and tado support these timed overrides.

[foxy82]

I'm testing this now. First problem is that if the mode is override you get a key error but I think that is related to the warmup api - another PR i've done to expose more data should fix that.

#6

I do feel the fact that if you have more than one device this is horribly inefficient as it polls the API and downloads every devices data each time you call update_room. So I have 5 devices so I make 5 api calls but on each one I get all the data so I could just make one. I'm going to see if I can fix that.

[rct]

@foxy82 - Thank you for your work on this. I've got 4 warmup4ie's installed, so I too would be very interested in some restructuring that would make things a bit more efficient.

[rct]

This might belong in a separate issue.

The current API uses one object to represent the connection and the current device. (The current device appears to be a room in warmup's terms, ) The queries used currently operate on all of the devices (rooms) and the data for the room other than the selected one is thrown away. (I don't know if multiple locations existed under one account if the API calls to warmup would return all locations and all devices at once.)

I think it might make sense to have an object that represents the connection to warmup and then a device object for each room would make more sense.

The connection object should probably keep track of when the data was last updated.

For use outside of home assistant, I'd prefer a model where the connection would return a list of locations/devices, or list of objects for each device, so no hard coded configuration for location names and room names would be needed. It's possible this model would also work better with home assistant auto discovery, but I don't know much about that yet. Currently __init__ calls self.get_all_devices which essentially does this.

Also, currently __init__ doesn't require a location or room name. When an object is instantiated without that, it seems to default to the first device. I don't know if that is supposed to work that way or not. If called without location/room names it could return a list of devices or objects.

The question is whether the break the currently exposed API at this point or not.

Thoughts?

[foxy82]

@PtolemyIV I've taken your work and exteded to reduce the number of API calls as well as some other good things. All in this PR:
#8

If you can try it out and let me know how you get on that would be great. @rct also any feedback would be appreciated.

[PtolemyIV]

Excellent will try it when back (in 10 days only tho)

[alex-0103]

hi folks,
just wanted to give a livesign. Indeed i was very busy the last months and was even unable to check the issues that have been raised in the last months.
After having upgraded my own HA installation to the latest version I can confirm that my original code was broken due to changes in HA that were introduced in Versions 0.9x+. I have checked the updated climate.py that has been submitted by @PtolemyIV at https://github.com/PtolemyIV/warmup4ie and confirm that this works for me. Very good work! Thanks!
Since i only work occasionally on this project, maybe someone is interested to take over this component and make it an official part HA? I attempted this in summer 2019 but then HA introduced breaking changes and I had no time to rewrite the code.
regards
Alex

[foxy82]

Thanks for all your work so far. PR #8 goes a little further and I've made it so that if you have multiple thermostats it updates them in a single call to My Warmup. Also it will auto detect and add all thermostats to HA that are in a warm-up account. However all of that will require a new version of the API being pushed to pypi. How do you feel about that? If you are happy I will try to get it integrated into HA.

[PtolemyIV]

Thanks for all your work so far. PR #8 goes a little further and I've made it so that if you have multiple thermostats it updates them in a single call to My Warmup. Also it will auto detect and add all thermostats to HA that are in a warm-up account. However all of that will require a new version of the API being pushed to pypi. How do you feel about that? If you are happy I will try to get it integrated into HA.

I agree this makes sense and thanks both