I stucked 
my climate.py not update-ing… it calls only the first time the update… how can I reach in program code it refreshing? maybe change the update interval?
"""Support for myIO thermostats."""
import logging
from datetime import timedelta
from homeassistant.util import slugify # entity_id friendly string converter
from homeassistant.components.climate import ClimateDevice
from homeassistant.helpers.entity import Entity
from homeassistant.const import (
CONF_NAME,
TEMP_CELSIUS,
ATTR_TEMPERATURE,
TEMP_FAHRENHEIT,
)
from homeassistant.components.climate.const import (
ATTR_TARGET_TEMP_HIGH,
ATTR_TARGET_TEMP_LOW,
CURRENT_HVAC_COOL,
CURRENT_HVAC_HEAT,
CURRENT_HVAC_IDLE,
FAN_AUTO,
FAN_ON,
HVAC_MODE_AUTO,
HVAC_MODE_COOL,
HVAC_MODE_HEAT,
HVAC_MODE_HEAT_COOL,
HVAC_MODE_OFF,
PRESET_AWAY,
PRESET_ECO,
PRESET_NONE,
SUPPORT_AUX_HEAT,
SUPPORT_FAN_MODE,
SUPPORT_PRESET_MODE,
SUPPORT_SWING_MODE,
SUPPORT_TARGET_HUMIDITY,
SUPPORT_TARGET_TEMPERATURE,
SUPPORT_TARGET_TEMPERATURE_RANGE,
)
from . import DOMAIN
_LOGGER = logging.getLogger(__name__)
SUPPORT_FLAGS = 0
SCAN_INTERVAL = timedelta(seconds=60)
async def async_setup_platform(hass, config, async_add_entities):
"""Set up the myIO-server platform."""
_LOGGER.warning("Loading myIO-Server via platform config is deprecated")
# Add defaults.
# async_add_entities([Sensor()])
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Add a weather entity from a config_entry."""
_LOGGER.debug(
"Loading "
+ config_entry.data[CONF_NAME]
+ " climate via platform async_setup_entry"
)
_id = 0
_server_name = slugify(config_entry.data[CONF_NAME])
_server_status = hass.states.get(_server_name + ".state").state
# _server_attr = hass.states.get(_server_name + ".state").attributes
_server_attr = hass.data[_server_name]
_climate_entities = []
if _server_status == "Online" or _server_status == "Refreshing":
for _relay in _server_attr["relays"]:
if _server_attr["relays"][_relay]["sensor"] != 0:
_id = _server_attr["relays"][_relay]["id"]
_climate_entities.append(MyIOThermostate(hass, _id, _server_name))
_LOGGER.debug("WIN")
try:
for _sensor in _server_attr["PWM"]:
if _server_attr["PWM"][_sensor]["sensor"] != 0:
_id = _sensor["id"]
_climate_entities.append(MyIOThermostate(hass, _id, _server_name))
except:
_LOGGER.debug("version <2.4.3")
async_add_entities(_climate_entities, True)
class MyIOThermostate(ClimateDevice):
"""Implementation of a myIO-Server."""
SCAN_INTERVAL = timedelta(seconds=5)
def __init__(self, hass, _id, _server_name):
"""Initialize the sensor."""
def id_converter(_eepromID):
"""Defining Sensor ID by EEPROMID"""
for _id in self._server_attr["sensors"]:
if self._server_attr["sensors"][_id]["id"] == _eepromID:
return _id
self._server_name = _server_name
self._server_attr = hass.data[_server_name]
self._id = _id
self.entity_id = f"climate.{_server_name}_{self._id}"
self._state = 0
self._name = ""
self._sensor = 0
self._sensorON = 0
self._sensorOFF = 0
if _id <= 64:
self._state = self._server_attr["relays"][str(self._id - 1)]["state"]
self._name = self._server_attr["relays"][str(self._id - 1)]["description"]
self._sensor = id_converter(
_eepromID=self._server_attr["relays"][str(self._id - 1)]["sensor"]
)
self._sensorON = (
self._server_attr["relays"][str(self._id - 1)]["sensorON"] / 10
)
self._sensorOFF = (
self._server_attr["relays"][str(self._id - 1)]["sensorOFF"] / 10
)
target_temperature = None
target_temperature_step = 0.1
precision = 0.1
current_temperature = self._server_attr["sensors"][self._sensor]["temp"] / 100
target_temp_high = self._sensorOFF
target_temp_low = self._sensorON
hvac_modes = [HVAC_MODE_COOL, HVAC_MODE_HEAT]
if self._sensorOFF > self._sensorON:
hvac_mode = HVAC_MODE_HEAT
else:
hvac_mode = HVAC_MODE_COOL
preset = "comfort"
fan_mode = None
target_humidity = None
swing_mode = None
hvac_action = None
aux = None
unit_of_measurement = TEMP_CELSIUS
preset_modes = ["comfort"]
current_humidity = None
"""Initialize the climate device."""
self._unique_id = _id
self._name = self._server_attr["relays"][str(self._id - 1)]["description"]
self._support_flags = SUPPORT_FLAGS
if target_temperature is not None:
self._support_flags = self._support_flags | SUPPORT_TARGET_TEMPERATURE
if preset is not None:
self._support_flags = self._support_flags | SUPPORT_PRESET_MODE
if fan_mode is not None:
self._support_flags = self._support_flags | SUPPORT_FAN_MODE
if target_humidity is not None:
self._support_flags = self._support_flags | SUPPORT_TARGET_HUMIDITY
if swing_mode is not None:
self._support_flags = self._support_flags | SUPPORT_SWING_MODE
if hvac_action is not None:
self._support_flags = self._support_flags
if aux is not None:
self._support_flags = self._support_flags | SUPPORT_AUX_HEAT
self._support_flags = self._support_flags | SUPPORT_TARGET_TEMPERATURE_RANGE
self._target_temperature = target_temperature
self._target_humidity = target_humidity
self._unit_of_measurement = unit_of_measurement
self._preset = preset
self._preset_modes = preset_modes
self._current_temperature = current_temperature
self._current_humidity = current_humidity
self._current_fan_mode = fan_mode
self._hvac_action = hvac_action
self._hvac_mode = hvac_mode
self._aux = aux
self._current_swing_mode = swing_mode
self._fan_modes = ["On Low", "On High", "Auto Low", "Auto High", "Off"]
self._hvac_modes = hvac_modes
self._swing_modes = ["Auto", "1", "2", "3", "Off"]
self._target_temperature_high = target_temp_high
self._target_temperature_low = target_temp_low
self._precision = precision
self._target_temperature_step = target_temperature_step
@property
def device_info(self):
"""Return device info."""
return {
"identifiers": {
# Serial numbers are unique identifiers within a specific domain
(DOMAIN, self.unique_id)
},
"name": self.name,
}
@property
def scan_interval(self):
"""Return the unique id."""
return SCAN_INTERVAL
@property
def unique_id(self):
"""Return the unique id."""
return self._unique_id
@property
def supported_features(self):
"""Return the list of supported features."""
return self._support_flags
@property
def should_poll(self):
"""Return the polling state."""
return False
@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._current_temperature
@property
def target_temperature(self):
"""Return the temperature we try to reach."""
return self._target_temperature
@property
def target_temperature_high(self):
"""Return the highbound target temperature we try to reach."""
return self._target_temperature_high
@property
def target_temperature_low(self):
"""Return the lowbound target temperature we try to reach."""
return self._target_temperature_low
@property
def current_humidity(self):
"""Return the current humidity."""
return self._current_humidity
@property
def target_humidity(self):
"""Return the humidity we try to reach."""
return self._target_humidity
@property
def hvac_action(self):
"""Return current operation ie. heat, cool, idle."""
return self._hvac_action
@property
def hvac_mode(self):
"""Return hvac target hvac state."""
return self._hvac_mode
@property
def hvac_modes(self):
"""Return the list of available operation modes."""
return self._hvac_modes
@property
def preset_mode(self):
"""Return preset mode."""
return self._preset
@property
def preset_modes(self):
"""Return preset modes."""
return self._preset_modes
@property
def is_aux_heat(self):
"""Return true if aux heat is on."""
return self._aux
@property
def fan_mode(self):
"""Return the fan setting."""
return self._current_fan_mode
@property
def fan_modes(self):
"""Return the list of available fan modes."""
return self._fan_modes
@property
def swing_mode(self):
"""Return the swing setting."""
return self._current_swing_mode
@property
def swing_modes(self):
"""List of available swing modes."""
return self._swing_modes
@property
def precision(self):
"""return the precision."""
return self._precision
@property
def target_temperature_step(self):
"""return the precision."""
return self._target_temperature_step
async def async_set_temperature(self, **kwargs):
"""Set new target temperatures."""
if kwargs.get(ATTR_TEMPERATURE) is not None:
self._target_temperature = kwargs.get(ATTR_TEMPERATURE)
if (
kwargs.get(ATTR_TARGET_TEMP_HIGH) is not None
and kwargs.get(ATTR_TARGET_TEMP_LOW) is not None
):
self._target_temperature_high = kwargs.get(ATTR_TARGET_TEMP_HIGH)
self._target_temperature_low = kwargs.get(ATTR_TARGET_TEMP_LOW)
self.async_write_ha_state()
async def async_set_humidity(self, humidity):
"""Set new humidity level."""
self._target_humidity = humidity
self.async_write_ha_state()
async def async_set_swing_mode(self, swing_mode):
"""Set new swing mode."""
self._current_swing_mode = swing_mode
self.async_write_ha_state()
async def async_set_fan_mode(self, fan_mode):
"""Set new fan mode."""
self._current_fan_mode = fan_mode
self.async_write_ha_state()
async def async_set_hvac_mode(self, hvac_mode):
"""Set new operation mode."""
self._hvac_mode = hvac_mode
self.async_write_ha_state()
async def async_set_preset_mode(self, preset_mode):
"""Update preset_mode on."""
self._preset = preset_mode
self.async_write_ha_state()
def turn_aux_heat_on(self):
"""Turn auxiliary heater on."""
self._aux = True
self.async_write_ha_state()
def turn_aux_heat_off(self):
"""Turn auxiliary heater off."""
self._aux = False
self.async_write_ha_state()
async def async_update(self):
"""Fetch new state data for the sensor.
This is the only method that should fetch new data for Home Assistant.
"""
_LOGGER.debug("UPDATE")
self._server_attr = self.hass.data[self._server_name]
self._target_temperature_low = (
self._server_attr["relays"][str(self._id - 1)]["sensorON"] / 10
)
self._target_temperature_high = (
self._server_attr["relays"][str(self._id - 1)]["sensorOFF"] / 10
)
self._current_temperature = (
self._server_attr["sensors"][self._sensor]["temp"] / 100
)
