mirror of
https://github.com/home-assistant/core.git
synced 2025-09-05 11:16:21 +00:00
.devcontainer
.github
.vscode
docs
homeassistant
auth
components
abode
accuweather
acer_projector
acmeda
actiontec
adax
adguard
ads
advantage_air
aemet
aftership
agent_dvr
air_quality
airly
airnow
airthings
airtouch4
airvisual
aladdin_connect
alarm_control_panel
alarmdecoder
alert
alexa
almond
alpha_vantage
amazon_polly
ambee
amberelectric
ambiclimate
ambient_station
amcrest
ampio
analytics
android_ip_webcam
androidtv
anel_pwrctrl
anthemav
apache_kafka
apcupsd
api
apns
apple_tv
apprise
aprs
aqualogic
aquostv
arcam_fmj
arduino
arest
arlo
arris_tg2492lg
aruba
arwn
asterisk_cdr
asterisk_mbox
asuswrt
atag
aten_pe
atome
august
aurora
aurora_abb_powerone
auth
automation
avea
avion
awair
aws
axis
azure_devops
azure_event_hub
azure_service_bus
baidu
bayesian
bbb_gpio
bbox
beewi_smartclim
bh1750
binary_sensor
bitcoin
bizkaibus
blackbird
blebox
blink
blinksticklight
blinkt
blockchain
bloomsky
blueprint
bluesound
bluetooth_le_tracker
bluetooth_tracker
bme280
bme680
bmp280
bmw_connected_drive
bond
bosch_shc
braviatv
broadlink
brother
brottsplatskartan
browser
brunt
bsblan
bt_home_hub_5
bt_smarthub
buienradar
caldav
calendar
camera
canary
cast
cert_expiry
channels
circuit
cisco_ios
cisco_mobility_express
cisco_webex_teams
citybikes
clementine
clickatell
clicksend
clicksend_tts
climacell
climate
cloud
cloudflare
cmus
co2signal
coinbase
color_extractor
comed_hourly_pricing
comfoconnect
command_line
compensation
concord232
config
configurator
control4
conversation
coolmaster
coronavirus
counter
cover
cppm_tracker
cpuspeed
crownstone
cups
currencylayer
daikin
danfoss_air
darksky
datadog
ddwrt
debugpy
deconz
decora
decora_wifi
default_config
delijn
deluge
demo
denon
denonavr
derivative
deutsche_bahn
device_automation
device_sun_light_trigger
device_tracker
devolo_home_control
devolo_home_network
dexcom
dhcp
dht
dialogflow
digital_ocean
digitalloggers
directv
discogs
discord
discovery
dlib_face_detect
dlib_face_identify
dlink
dlna_dmr
dnsip
dominos
doods
doorbird
dovado
downloader
dsmr
dsmr_reader
dte_energy_bridge
dublin_bus_transport
duckdns
dunehd
dwd_weather_warnings
dweet
dynalite
dyson
eafm
ebox
ebusd
ecoal_boiler
ecobee
econet
ecovacs
eddystone_temperature
edimax
edl21
ee_brightbox
efergy
egardia
eight_sleep
elgato
eliqonline
elkm1
elv
emby
emoncms
emoncms_history
emonitor
emulated_hue
emulated_kasa
emulated_roku
energy
enigma2
enocean
enphase_envoy
entur_public_transport
environment_canada
envirophat
envisalink
ephember
epson
epsonworkforce
eq3btsmart
esphome
etherscan
eufy
everlights
evohome
ezviz
faa_delays
facebook
facebox
fail2ban
familyhub
fan
fastdotcom
feedreader
ffmpeg
ffmpeg_motion
ffmpeg_noise
fibaro
fido
file
filesize
filter
fints
fireservicerota
firmata
fitbit
fixer
fjaraskupan
fleetgo
flexit
flic
flick_electric
flipr
flo
flock
flume
flunearyou
flux
flux_led
folder
folder_watcher
foobot
forecast_solar
forked_daapd
fortios
foscam
foursquare
free_mobile
freebox
freedns
freedompro
fritz
fritzbox
fritzbox_callmonitor
fronius
frontend
frontier_silicon
futurenow
garadget
garages_amsterdam
gc100
gdacs
generic
generic_hygrostat
generic_thermostat
geniushub
geo_json_events
geo_location
geo_rss_events
geofency
geonetnz_quakes
geonetnz_volcano
gios
github
gitlab_ci
gitter
glances
gntp
goalfeed
goalzero
gogogate2
google
google_assistant
google_cloud
google_domains
google_maps
google_pubsub
google_translate
google_travel_time
google_wifi
gpmdp
gpsd
gpslogger
graphite
gree
greeneye_monitor
greenwave
group
growatt_server
gstreamer
gtfs
guardian
habitica
hangouts
harman_kardon_avr
harmony
hassio
haveibeenpwned
hddtemp
hdmi_cec
heatmiser
heos
here_travel_time
hikvision
hikvisioncam
hisense_aehw4a1
history
history_stats
hitron_coda
hive
hlk_sw16
home_connect
home_plus_control
homeassistant
homekit
homekit_controller
homematic
homematicip_cloud
homeworks
honeywell
horizon
hp_ilo
html5
http
htu21d
huawei_lte
hue
huisbaasje
humidifier
hunterdouglas_powerview
hvv_departures
hydrawise
hyperion
ialarm
iammeter
iaqualink
icloud
idteck_prox
ifttt
iglo
ign_sismologia
ihc
image
image_processing
imap
imap_email_content
incomfort
influxdb
input_boolean
input_datetime
input_number
input_select
input_text
insteon
integration
intent
intent_script
intesishome
ios
iota
iotawatt
iperf3
ipma
ipp
iqvia
irish_rail_transport
islamic_prayer_times
iss
isy994
itach
itunes
izone
jewish_calendar
joaoapps_join
juicenet
kaiterra
kankun
keba
keenetic_ndms2
kef
keyboard
keyboard_remote
kira
kiwi
kmtronic
knx
kodi
konnected
kostal_plenticore
kraken
kulersky
kwb
lacrosse
lametric
lannouncer
lastfm
launch_library
lcn
lg_netcast
lg_soundbar
life360
lifx
lifx_cloud
light
lightwave
limitlessled
linksys_smart
linode
linux_battery
lirc
litejet
litterrobot
llamalab_automate
local_file
local_ip
locative
lock
logbook
logentries
logger
logi_circle
london_air
london_underground
lookin
loopenergy
lovelace
luci
luftdaten
lupusec
lutron
lutron_caseta
lw12wifi
lyric
magicseaweed
mailbox
mailgun
manual
manual_mqtt
map
marytts
mastodon
matrix
maxcube
mazda
mcp23017
media_extractor
media_player
media_source
mediaroom
melcloud
melissa
meraki
message_bird
met
met_eireann
meteo_france
meteoalarm
meteoclimatic
metoffice
mfi
mhz19
microsoft
microsoft_face
microsoft_face_detect
microsoft_face_identify
miflora
mikrotik
mill
min_max
minecraft_server
minio
mitemp_bt
mjpeg
mobile_app
mochad
modbus
modem_callerid
modern_forms
mold_indicator
monoprice
moon
motion_blinds
motioneye
mpchc
mpd
mqtt
mqtt_eventstream
mqtt_json
mqtt_room
mqtt_statestream
msteams
mullvad
mutesync
mvglive
my
mychevy
mycroft
myq
mysensors
mystrom
mythicbeastsdns
nad
nam
namecheapdns
nanoleaf
neato
nederlandse_spoorwegen
ness_alarm
nest
netatmo
netdata
netgear
netgear_lte
netio
network
neurio_energy
nexia
nextbus
nextcloud
nfandroidtv
nightscout
niko_home_control
nilu
nissan_leaf
nmap_tracker
nmbs
no_ip
noaa_tides
norway_air
notify
notify_events
notion
nsw_fuel_station
nsw_rural_fire_service_feed
nuheat
nuki
numato
number
nut
nws
nx584
nzbget
oasa_telematics
obihai
octoprint
oem
ohmconnect
ombi
omnilogic
onboarding
ondilo_ico
onewire
onkyo
onvif
openalpr_cloud
openalpr_local
opencv
openerz
openevse
openexchangerates
opengarage
openhardwaremonitor
openhome
opensensemap
opensky
opentherm_gw
openuv
openweathermap
opnsense
opple
orangepi_gpio
oru
orvibo
osramlightify
otp
ovo_energy
owntracks
ozw
p1_monitor
panasonic_bluray
panasonic_viera
pandora
panel_custom
panel_iframe
pcal9535a
pencom
persistent_notification
person
philips_js
pi4ioe5v9xxxx
pi_hole
picnic
picotts
piglow
pilight
ping
pioneer
pjlink
plaato
plant
plex
plugwise
plum_lightpad
pocketcasts
point
poolsense
powerwall
profiler
progettihwsw
proliphix
prometheus
prosegur
prowl
proximity
proxmoxve
proxy
ps4
pulseaudio_loopback
push
pushbullet
pushover
pushsafer
pvoutput
pvpc_hourly_pricing
pyload
python_script
qbittorrent
qld_bushfire
qnap
qrcode
quantum_gateway
qvr_pro
qwikswitch
rachio
radarr
radiotherm
rainbird
raincloud
rainforest_eagle
rainmachine
random
raspihats
raspyrfm
recollect_waste
recorder
recswitch
reddit
rejseplanen
remember_the_milk
remote
remote_rpi_gpio
renault
repetier
rest
rest_command
rflink
rfxtrx
ridwell
ring
ripple
risco
rituals_perfume_genie
rmvtransport
rocketchat
roku
roomba
roon
route53
rova
rpi_camera
rpi_gpio
rpi_gpio_pwm
rpi_pfio
rpi_power
rpi_rf
rss_feed_template
rtorrent
ruckus_unleashed
russound_rio
russound_rnet
sabnzbd
safe_mode
saj
samsungtv
satel_integra
scene
schluter
scrape
screenlogic
script
scsgate
search
season
select
sendgrid
sense
sensehat
sensibo
sensor
sentry
serial
serial_pm
sesame
seven_segments
seventeentrack
sharkiq
shell_command
shelly
shiftr
shodan
shopping_list
sht31
sia
sigfox
sighthound
signal_messenger
simplepush
simplisafe
simulated
sinch
siren
sisyphus
sky_hub
skybeacon
skybell
slack
sleepiq
slide
sma
smappee
smart_meter_texas
smarthab
smartthings
smarttub
smarty
smhi
sms
smtp
snapcast
snips
snmp
sochain
solaredge
solaredge_local
solarlog
solax
soma
somfy
somfy_mylink
sonarr
songpal
sonos
sony_projector
soundtouch
spaceapi
spc
speedtestdotnet
spider
splunk
spotify
sql
squeezebox
srp_energy
ssdp
starline
starlingbank
startca
statistics
statsd
steam_online
stiebel_eltron
stookalert
stream
streamlabswater
stt
subaru
suez_water
sun
supervisord
supla
surepetcare
swiss_hydrological_data
swiss_public_transport
swisscom
switch
switchbot
switcher_kis
switchmate
syncthing
syncthru
synology_chat
synology_dsm
synology_srm
syslog
system_bridge
system_health
system_log
systemmonitor
tado
tag
tahoma
tank_utility
tankerkoenig
tapsaff
tasmota
tautulli
tcp
ted5000
telegram
telegram_bot
tellduslive
tellstick
telnet
temper
template
tensorflow
tfiac
thermoworks_smoke
thethingsnetwork
thingspeak
thinkingcleaner
thomson
threshold
tibber
tikteck
tile
time_date
timer
tmb
tod
todoist
tof
tomato
toon
torque
totalconnect
touchline
tplink
tplink_lte
traccar
trace
tractive
tradfri
trafikverket_train
trafikverket_weatherstation
transmission
transport_nsw
travisci
trend
tts
tuya
twentemilieu
twilio
twilio_call
twilio_sms
twinkly
twitch
twitter
ubus
ue_smart_radio
uk_transport
unifi
unifi_direct
unifiled
universal
upb
upc_connect
upcloud
updater
upnp
uptime
uptimerobot
usb
uscis
usgs_earthquakes_feed
utility_meter
uvc
vacuum
vallox
vasttrafik
velbus
velux
venstar
vera
verisure
versasense
version
vesync
viaggiatreno
vicare
vilfo
vivotek
vizio
vlc
vlc_telnet
voicerss
volkszaehler
volumio
volvooncall
vultr
w800rf32
wake_on_lan
wallbox
waqi
water_heater
waterfurnace
watson_iot
watson_tts
watttime
waze_travel_time
weather
webhook
webostv
websocket_api
wemo
whirlpool
whois
wiffi
wilight
wirelesstag
withings
wled
wolflink
workday
worldclock
worldtidesinfo
worxlandroid
wsdot
x10
xbee
xbox
xbox_live
xeoma
xiaomi
xiaomi_aqara
xiaomi_miio
xiaomi_tv
xmpp
xs1
yale_smart_alarm
yamaha
yamaha_musiccast
yandex_transport
yandextts
yeelight
yeelightsunflower
yi
youless
zabbix
zamg
zengge
zeroconf
zerproc
zestimate
zha
core
translations
__init__.py
alarm_control_panel.py
api.py
binary_sensor.py
climate.py
config_flow.py
cover.py
device_action.py
device_tracker.py
device_trigger.py
entity.py
fan.py
light.py
lock.py
manifest.json
number.py
sensor.py
services.yaml
strings.json
switch.py
zhong_hong
ziggo_mediabox_xl
zodiac
zone
zoneminder
zwave
zwave_js
__init__.py
generated
helpers
scripts
util
__init__.py
__main__.py
block_async_io.py
bootstrap.py
config.py
config_entries.py
const.py
core.py
data_entry_flow.py
exceptions.py
loader.py
package_constraints.txt
requirements.py
runner.py
setup.py
strings.json
machine
pylint
rootfs
script
tests
.coveragerc
.dockerignore
.gitattributes
.gitignore
.hadolint.yaml
.ignore
.pre-commit-config.yaml
.prettierignore
.readthedocs.yml
.strict-typing
.yamllint
CLA.md
CODEOWNERS
CODE_OF_CONDUCT.md
CONTRIBUTING.md
Dockerfile
Dockerfile.dev
LICENSE.md
MANIFEST.in
README.rst
build.json
codecov.yml
mypy.ini
pyproject.toml
requirements.txt
requirements_all.txt
requirements_docs.txt
requirements_test.txt
requirements_test_all.txt
requirements_test_pre_commit.txt
setup.cfg
setup.py
tox.ini
697 lines
23 KiB
Python
697 lines
23 KiB
Python
"""
|
|
Climate on Zigbee Home Automation networks.
|
|
|
|
For more details on this platform, please refer to the documentation
|
|
at https://home-assistant.io/components/zha.climate/
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from datetime import datetime, timedelta
|
|
import enum
|
|
import functools
|
|
from random import randint
|
|
|
|
from homeassistant.components.climate import ClimateEntity
|
|
from homeassistant.components.climate.const import (
|
|
ATTR_HVAC_MODE,
|
|
ATTR_TARGET_TEMP_HIGH,
|
|
ATTR_TARGET_TEMP_LOW,
|
|
CURRENT_HVAC_COOL,
|
|
CURRENT_HVAC_FAN,
|
|
CURRENT_HVAC_HEAT,
|
|
CURRENT_HVAC_IDLE,
|
|
CURRENT_HVAC_OFF,
|
|
DOMAIN,
|
|
FAN_AUTO,
|
|
FAN_ON,
|
|
HVAC_MODE_COOL,
|
|
HVAC_MODE_DRY,
|
|
HVAC_MODE_FAN_ONLY,
|
|
HVAC_MODE_HEAT,
|
|
HVAC_MODE_HEAT_COOL,
|
|
HVAC_MODE_OFF,
|
|
PRESET_AWAY,
|
|
PRESET_BOOST,
|
|
PRESET_COMFORT,
|
|
PRESET_ECO,
|
|
PRESET_NONE,
|
|
SUPPORT_FAN_MODE,
|
|
SUPPORT_PRESET_MODE,
|
|
SUPPORT_TARGET_TEMPERATURE,
|
|
SUPPORT_TARGET_TEMPERATURE_RANGE,
|
|
)
|
|
from homeassistant.const import ATTR_TEMPERATURE, PRECISION_TENTHS, TEMP_CELSIUS
|
|
from homeassistant.core import callback
|
|
from homeassistant.helpers.dispatcher import async_dispatcher_connect
|
|
from homeassistant.helpers.event import async_track_time_interval
|
|
import homeassistant.util.dt as dt_util
|
|
|
|
from .core import discovery
|
|
from .core.const import (
|
|
CHANNEL_FAN,
|
|
CHANNEL_THERMOSTAT,
|
|
DATA_ZHA,
|
|
DATA_ZHA_DISPATCHERS,
|
|
PRESET_COMPLEX,
|
|
PRESET_SCHEDULE,
|
|
SIGNAL_ADD_ENTITIES,
|
|
SIGNAL_ATTR_UPDATED,
|
|
)
|
|
from .core.registries import ZHA_ENTITIES
|
|
from .entity import ZhaEntity
|
|
|
|
ATTR_SYS_MODE = "system_mode"
|
|
ATTR_RUNNING_MODE = "running_mode"
|
|
ATTR_SETPT_CHANGE_SRC = "setpoint_change_source"
|
|
ATTR_SETPT_CHANGE_AMT = "setpoint_change_amount"
|
|
ATTR_OCCUPANCY = "occupancy"
|
|
ATTR_PI_COOLING_DEMAND = "pi_cooling_demand"
|
|
ATTR_PI_HEATING_DEMAND = "pi_heating_demand"
|
|
ATTR_OCCP_COOL_SETPT = "occupied_cooling_setpoint"
|
|
ATTR_OCCP_HEAT_SETPT = "occupied_heating_setpoint"
|
|
ATTR_UNOCCP_HEAT_SETPT = "unoccupied_heating_setpoint"
|
|
ATTR_UNOCCP_COOL_SETPT = "unoccupied_cooling_setpoint"
|
|
|
|
|
|
STRICT_MATCH = functools.partial(ZHA_ENTITIES.strict_match, DOMAIN)
|
|
MULTI_MATCH = functools.partial(ZHA_ENTITIES.multipass_match, DOMAIN)
|
|
RUNNING_MODE = {0x00: HVAC_MODE_OFF, 0x03: HVAC_MODE_COOL, 0x04: HVAC_MODE_HEAT}
|
|
|
|
|
|
class ThermostatFanMode(enum.IntEnum):
|
|
"""Fan channel enum for thermostat Fans."""
|
|
|
|
OFF = 0x00
|
|
ON = 0x04
|
|
AUTO = 0x05
|
|
|
|
|
|
class RunningState(enum.IntFlag):
|
|
"""ZCL Running state enum."""
|
|
|
|
HEAT = 0x0001
|
|
COOL = 0x0002
|
|
FAN = 0x0004
|
|
HEAT_STAGE_2 = 0x0008
|
|
COOL_STAGE_2 = 0x0010
|
|
FAN_STAGE_2 = 0x0020
|
|
FAN_STAGE_3 = 0x0040
|
|
|
|
|
|
SEQ_OF_OPERATION = {
|
|
0x00: (HVAC_MODE_OFF, HVAC_MODE_COOL), # cooling only
|
|
0x01: (HVAC_MODE_OFF, HVAC_MODE_COOL), # cooling with reheat
|
|
0x02: (HVAC_MODE_OFF, HVAC_MODE_HEAT), # heating only
|
|
0x03: (HVAC_MODE_OFF, HVAC_MODE_HEAT), # heating with reheat
|
|
# cooling and heating 4-pipes
|
|
0x04: (HVAC_MODE_OFF, HVAC_MODE_HEAT_COOL, HVAC_MODE_COOL, HVAC_MODE_HEAT),
|
|
# cooling and heating 4-pipes
|
|
0x05: (HVAC_MODE_OFF, HVAC_MODE_HEAT_COOL, HVAC_MODE_COOL, HVAC_MODE_HEAT),
|
|
0x06: (HVAC_MODE_COOL, HVAC_MODE_HEAT, HVAC_MODE_OFF), # centralite specific
|
|
0x07: (HVAC_MODE_HEAT_COOL, HVAC_MODE_OFF), # centralite specific
|
|
}
|
|
|
|
|
|
class SystemMode(enum.IntEnum):
|
|
"""ZCL System Mode attribute enum."""
|
|
|
|
OFF = 0x00
|
|
HEAT_COOL = 0x01
|
|
COOL = 0x03
|
|
HEAT = 0x04
|
|
AUX_HEAT = 0x05
|
|
PRE_COOL = 0x06
|
|
FAN_ONLY = 0x07
|
|
DRY = 0x08
|
|
SLEEP = 0x09
|
|
|
|
|
|
HVAC_MODE_2_SYSTEM = {
|
|
HVAC_MODE_OFF: SystemMode.OFF,
|
|
HVAC_MODE_HEAT_COOL: SystemMode.HEAT_COOL,
|
|
HVAC_MODE_COOL: SystemMode.COOL,
|
|
HVAC_MODE_HEAT: SystemMode.HEAT,
|
|
HVAC_MODE_FAN_ONLY: SystemMode.FAN_ONLY,
|
|
HVAC_MODE_DRY: SystemMode.DRY,
|
|
}
|
|
|
|
SYSTEM_MODE_2_HVAC = {
|
|
SystemMode.OFF: HVAC_MODE_OFF,
|
|
SystemMode.HEAT_COOL: HVAC_MODE_HEAT_COOL,
|
|
SystemMode.COOL: HVAC_MODE_COOL,
|
|
SystemMode.HEAT: HVAC_MODE_HEAT,
|
|
SystemMode.AUX_HEAT: HVAC_MODE_HEAT,
|
|
SystemMode.PRE_COOL: HVAC_MODE_COOL, # this is 'precooling'. is it the same?
|
|
SystemMode.FAN_ONLY: HVAC_MODE_FAN_ONLY,
|
|
SystemMode.DRY: HVAC_MODE_DRY,
|
|
SystemMode.SLEEP: HVAC_MODE_OFF,
|
|
}
|
|
|
|
ZCL_TEMP = 100
|
|
|
|
|
|
async def async_setup_entry(hass, config_entry, async_add_entities):
|
|
"""Set up the Zigbee Home Automation sensor from config entry."""
|
|
entities_to_create = hass.data[DATA_ZHA][DOMAIN]
|
|
unsub = async_dispatcher_connect(
|
|
hass,
|
|
SIGNAL_ADD_ENTITIES,
|
|
functools.partial(
|
|
discovery.async_add_entities, async_add_entities, entities_to_create
|
|
),
|
|
)
|
|
hass.data[DATA_ZHA][DATA_ZHA_DISPATCHERS].append(unsub)
|
|
|
|
|
|
@MULTI_MATCH(channel_names=CHANNEL_THERMOSTAT, aux_channels=CHANNEL_FAN)
|
|
class Thermostat(ZhaEntity, ClimateEntity):
|
|
"""Representation of a ZHA Thermostat device."""
|
|
|
|
DEFAULT_MAX_TEMP = 35
|
|
DEFAULT_MIN_TEMP = 7
|
|
|
|
def __init__(self, unique_id, zha_device, channels, **kwargs):
|
|
"""Initialize ZHA Thermostat instance."""
|
|
super().__init__(unique_id, zha_device, channels, **kwargs)
|
|
self._thrm = self.cluster_channels.get(CHANNEL_THERMOSTAT)
|
|
self._preset = PRESET_NONE
|
|
self._presets = []
|
|
self._supported_flags = SUPPORT_TARGET_TEMPERATURE
|
|
self._fan = self.cluster_channels.get(CHANNEL_FAN)
|
|
|
|
@property
|
|
def current_temperature(self):
|
|
"""Return the current temperature."""
|
|
if self._thrm.local_temp is None:
|
|
return None
|
|
return self._thrm.local_temp / ZCL_TEMP
|
|
|
|
@property
|
|
def extra_state_attributes(self):
|
|
"""Return device specific state attributes."""
|
|
data = {}
|
|
if self.hvac_mode:
|
|
mode = SYSTEM_MODE_2_HVAC.get(self._thrm.system_mode, "unknown")
|
|
data[ATTR_SYS_MODE] = f"[{self._thrm.system_mode}]/{mode}"
|
|
if self._thrm.occupancy is not None:
|
|
data[ATTR_OCCUPANCY] = self._thrm.occupancy
|
|
if self._thrm.occupied_cooling_setpoint is not None:
|
|
data[ATTR_OCCP_COOL_SETPT] = self._thrm.occupied_cooling_setpoint
|
|
if self._thrm.occupied_heating_setpoint is not None:
|
|
data[ATTR_OCCP_HEAT_SETPT] = self._thrm.occupied_heating_setpoint
|
|
if self._thrm.pi_heating_demand is not None:
|
|
data[ATTR_PI_HEATING_DEMAND] = self._thrm.pi_heating_demand
|
|
if self._thrm.pi_cooling_demand is not None:
|
|
data[ATTR_PI_COOLING_DEMAND] = self._thrm.pi_cooling_demand
|
|
|
|
unoccupied_cooling_setpoint = self._thrm.unoccupied_cooling_setpoint
|
|
if unoccupied_cooling_setpoint is not None:
|
|
data[ATTR_UNOCCP_HEAT_SETPT] = unoccupied_cooling_setpoint
|
|
|
|
unoccupied_heating_setpoint = self._thrm.unoccupied_heating_setpoint
|
|
if unoccupied_heating_setpoint is not None:
|
|
data[ATTR_UNOCCP_COOL_SETPT] = unoccupied_heating_setpoint
|
|
return data
|
|
|
|
@property
|
|
def fan_mode(self) -> str | None:
|
|
"""Return current FAN mode."""
|
|
if self._thrm.running_state is None:
|
|
return FAN_AUTO
|
|
|
|
if self._thrm.running_state & (
|
|
RunningState.FAN | RunningState.FAN_STAGE_2 | RunningState.FAN_STAGE_3
|
|
):
|
|
return FAN_ON
|
|
return FAN_AUTO
|
|
|
|
@property
|
|
def fan_modes(self) -> list[str] | None:
|
|
"""Return supported FAN modes."""
|
|
if not self._fan:
|
|
return None
|
|
return [FAN_AUTO, FAN_ON]
|
|
|
|
@property
|
|
def hvac_action(self) -> str | None:
|
|
"""Return the current HVAC action."""
|
|
if (
|
|
self._thrm.pi_heating_demand is None
|
|
and self._thrm.pi_cooling_demand is None
|
|
):
|
|
return self._rm_rs_action
|
|
return self._pi_demand_action
|
|
|
|
@property
|
|
def _rm_rs_action(self) -> str | None:
|
|
"""Return the current HVAC action based on running mode and running state."""
|
|
|
|
running_mode = self._thrm.running_mode
|
|
if running_mode == SystemMode.HEAT:
|
|
return CURRENT_HVAC_HEAT
|
|
if running_mode == SystemMode.COOL:
|
|
return CURRENT_HVAC_COOL
|
|
|
|
running_state = self._thrm.running_state
|
|
if running_state and running_state & (
|
|
RunningState.FAN | RunningState.FAN_STAGE_2 | RunningState.FAN_STAGE_3
|
|
):
|
|
return CURRENT_HVAC_FAN
|
|
if self.hvac_mode != HVAC_MODE_OFF and running_mode == SystemMode.OFF:
|
|
return CURRENT_HVAC_IDLE
|
|
return CURRENT_HVAC_OFF
|
|
|
|
@property
|
|
def _pi_demand_action(self) -> str | None:
|
|
"""Return the current HVAC action based on pi_demands."""
|
|
|
|
heating_demand = self._thrm.pi_heating_demand
|
|
if heating_demand is not None and heating_demand > 0:
|
|
return CURRENT_HVAC_HEAT
|
|
cooling_demand = self._thrm.pi_cooling_demand
|
|
if cooling_demand is not None and cooling_demand > 0:
|
|
return CURRENT_HVAC_COOL
|
|
|
|
if self.hvac_mode != HVAC_MODE_OFF:
|
|
return CURRENT_HVAC_IDLE
|
|
return CURRENT_HVAC_OFF
|
|
|
|
@property
|
|
def hvac_mode(self) -> str | None:
|
|
"""Return HVAC operation mode."""
|
|
return SYSTEM_MODE_2_HVAC.get(self._thrm.system_mode)
|
|
|
|
@property
|
|
def hvac_modes(self) -> tuple[str, ...]:
|
|
"""Return the list of available HVAC operation modes."""
|
|
return SEQ_OF_OPERATION.get(self._thrm.ctrl_seqe_of_oper, (HVAC_MODE_OFF,))
|
|
|
|
@property
|
|
def precision(self):
|
|
"""Return the precision of the system."""
|
|
return PRECISION_TENTHS
|
|
|
|
@property
|
|
def preset_mode(self) -> str | None:
|
|
"""Return current preset mode."""
|
|
return self._preset
|
|
|
|
@property
|
|
def preset_modes(self) -> list[str] | None:
|
|
"""Return supported preset modes."""
|
|
return self._presets
|
|
|
|
@property
|
|
def supported_features(self):
|
|
"""Return the list of supported features."""
|
|
features = self._supported_flags
|
|
if HVAC_MODE_HEAT_COOL in self.hvac_modes:
|
|
features |= SUPPORT_TARGET_TEMPERATURE_RANGE
|
|
if self._fan is not None:
|
|
self._supported_flags |= SUPPORT_FAN_MODE
|
|
return features
|
|
|
|
@property
|
|
def target_temperature(self):
|
|
"""Return the temperature we try to reach."""
|
|
temp = None
|
|
if self.hvac_mode == HVAC_MODE_COOL:
|
|
if self.preset_mode == PRESET_AWAY:
|
|
temp = self._thrm.unoccupied_cooling_setpoint
|
|
else:
|
|
temp = self._thrm.occupied_cooling_setpoint
|
|
elif self.hvac_mode == HVAC_MODE_HEAT:
|
|
if self.preset_mode == PRESET_AWAY:
|
|
temp = self._thrm.unoccupied_heating_setpoint
|
|
else:
|
|
temp = self._thrm.occupied_heating_setpoint
|
|
if temp is None:
|
|
return temp
|
|
return round(temp / ZCL_TEMP, 1)
|
|
|
|
@property
|
|
def target_temperature_high(self):
|
|
"""Return the upper bound temperature we try to reach."""
|
|
if self.hvac_mode != HVAC_MODE_HEAT_COOL:
|
|
return None
|
|
if self.preset_mode == PRESET_AWAY:
|
|
temp = self._thrm.unoccupied_cooling_setpoint
|
|
else:
|
|
temp = self._thrm.occupied_cooling_setpoint
|
|
|
|
if temp is None:
|
|
return temp
|
|
|
|
return round(temp / ZCL_TEMP, 1)
|
|
|
|
@property
|
|
def target_temperature_low(self):
|
|
"""Return the lower bound temperature we try to reach."""
|
|
if self.hvac_mode != HVAC_MODE_HEAT_COOL:
|
|
return None
|
|
if self.preset_mode == PRESET_AWAY:
|
|
temp = self._thrm.unoccupied_heating_setpoint
|
|
else:
|
|
temp = self._thrm.occupied_heating_setpoint
|
|
|
|
if temp is None:
|
|
return temp
|
|
return round(temp / ZCL_TEMP, 1)
|
|
|
|
@property
|
|
def temperature_unit(self):
|
|
"""Return the unit of measurement used by the platform."""
|
|
return TEMP_CELSIUS
|
|
|
|
@property
|
|
def max_temp(self) -> float:
|
|
"""Return the maximum temperature."""
|
|
temps = []
|
|
if HVAC_MODE_HEAT in self.hvac_modes:
|
|
temps.append(self._thrm.max_heat_setpoint_limit)
|
|
if HVAC_MODE_COOL in self.hvac_modes:
|
|
temps.append(self._thrm.max_cool_setpoint_limit)
|
|
|
|
if not temps:
|
|
return self.DEFAULT_MAX_TEMP
|
|
return round(max(temps) / ZCL_TEMP, 1)
|
|
|
|
@property
|
|
def min_temp(self) -> float:
|
|
"""Return the minimum temperature."""
|
|
temps = []
|
|
if HVAC_MODE_HEAT in self.hvac_modes:
|
|
temps.append(self._thrm.min_heat_setpoint_limit)
|
|
if HVAC_MODE_COOL in self.hvac_modes:
|
|
temps.append(self._thrm.min_cool_setpoint_limit)
|
|
|
|
if not temps:
|
|
return self.DEFAULT_MIN_TEMP
|
|
return round(min(temps) / ZCL_TEMP, 1)
|
|
|
|
async def async_added_to_hass(self):
|
|
"""Run when about to be added to hass."""
|
|
await super().async_added_to_hass()
|
|
self.async_accept_signal(
|
|
self._thrm, SIGNAL_ATTR_UPDATED, self.async_attribute_updated
|
|
)
|
|
|
|
async def async_attribute_updated(self, record):
|
|
"""Handle attribute update from device."""
|
|
if (
|
|
record.attr_name in (ATTR_OCCP_COOL_SETPT, ATTR_OCCP_HEAT_SETPT)
|
|
and self.preset_mode == PRESET_AWAY
|
|
):
|
|
# occupancy attribute is an unreportable attribute, but if we get
|
|
# an attribute update for an "occupied" setpoint, there's a chance
|
|
# occupancy has changed
|
|
occupancy = await self._thrm.get_occupancy()
|
|
if occupancy is True:
|
|
self._preset = PRESET_NONE
|
|
|
|
self.debug("Attribute '%s' = %s update", record.attr_name, record.value)
|
|
self.async_write_ha_state()
|
|
|
|
async def async_set_fan_mode(self, fan_mode: str) -> None:
|
|
"""Set fan mode."""
|
|
if fan_mode not in self.fan_modes:
|
|
self.warning("Unsupported '%s' fan mode", fan_mode)
|
|
return
|
|
|
|
if fan_mode == FAN_ON:
|
|
mode = ThermostatFanMode.ON
|
|
else:
|
|
mode = ThermostatFanMode.AUTO
|
|
|
|
await self._fan.async_set_speed(mode)
|
|
|
|
async def async_set_hvac_mode(self, hvac_mode: str) -> None:
|
|
"""Set new target operation mode."""
|
|
if hvac_mode not in self.hvac_modes:
|
|
self.warning(
|
|
"can't set '%s' mode. Supported modes are: %s",
|
|
hvac_mode,
|
|
self.hvac_modes,
|
|
)
|
|
return
|
|
|
|
if await self._thrm.async_set_operation_mode(HVAC_MODE_2_SYSTEM[hvac_mode]):
|
|
self.async_write_ha_state()
|
|
|
|
async def async_set_preset_mode(self, preset_mode: str) -> None:
|
|
"""Set new preset mode."""
|
|
if preset_mode not in self.preset_modes:
|
|
self.debug("preset mode '%s' is not supported", preset_mode)
|
|
return
|
|
|
|
if (
|
|
self.preset_mode
|
|
not in (
|
|
preset_mode,
|
|
PRESET_NONE,
|
|
)
|
|
and not await self.async_preset_handler(self.preset_mode, enable=False)
|
|
):
|
|
self.debug("Couldn't turn off '%s' preset", self.preset_mode)
|
|
return
|
|
|
|
if preset_mode != PRESET_NONE and not await self.async_preset_handler(
|
|
preset_mode, enable=True
|
|
):
|
|
self.debug("Couldn't turn on '%s' preset", preset_mode)
|
|
return
|
|
self._preset = preset_mode
|
|
self.async_write_ha_state()
|
|
|
|
async def async_set_temperature(self, **kwargs):
|
|
"""Set new target temperature."""
|
|
low_temp = kwargs.get(ATTR_TARGET_TEMP_LOW)
|
|
high_temp = kwargs.get(ATTR_TARGET_TEMP_HIGH)
|
|
temp = kwargs.get(ATTR_TEMPERATURE)
|
|
hvac_mode = kwargs.get(ATTR_HVAC_MODE)
|
|
|
|
if hvac_mode is not None:
|
|
await self.async_set_hvac_mode(hvac_mode)
|
|
|
|
thrm = self._thrm
|
|
if self.hvac_mode == HVAC_MODE_HEAT_COOL:
|
|
success = True
|
|
if low_temp is not None:
|
|
low_temp = int(low_temp * ZCL_TEMP)
|
|
success = success and await thrm.async_set_heating_setpoint(
|
|
low_temp, self.preset_mode == PRESET_AWAY
|
|
)
|
|
self.debug("Setting heating %s setpoint: %s", low_temp, success)
|
|
if high_temp is not None:
|
|
high_temp = int(high_temp * ZCL_TEMP)
|
|
success = success and await thrm.async_set_cooling_setpoint(
|
|
high_temp, self.preset_mode == PRESET_AWAY
|
|
)
|
|
self.debug("Setting cooling %s setpoint: %s", low_temp, success)
|
|
elif temp is not None:
|
|
temp = int(temp * ZCL_TEMP)
|
|
if self.hvac_mode == HVAC_MODE_COOL:
|
|
success = await thrm.async_set_cooling_setpoint(
|
|
temp, self.preset_mode == PRESET_AWAY
|
|
)
|
|
elif self.hvac_mode == HVAC_MODE_HEAT:
|
|
success = await thrm.async_set_heating_setpoint(
|
|
temp, self.preset_mode == PRESET_AWAY
|
|
)
|
|
else:
|
|
self.debug("Not setting temperature for '%s' mode", self.hvac_mode)
|
|
return
|
|
else:
|
|
self.debug("incorrect %s setting for '%s' mode", kwargs, self.hvac_mode)
|
|
return
|
|
|
|
if success:
|
|
self.async_write_ha_state()
|
|
|
|
async def async_preset_handler(self, preset: str, enable: bool = False) -> bool:
|
|
"""Set the preset mode via handler."""
|
|
|
|
handler = getattr(self, f"async_preset_handler_{preset}")
|
|
return await handler(enable)
|
|
|
|
|
|
@MULTI_MATCH(
|
|
channel_names={CHANNEL_THERMOSTAT, "sinope_manufacturer_specific"},
|
|
manufacturers="Sinope Technologies",
|
|
stop_on_match=True,
|
|
)
|
|
class SinopeTechnologiesThermostat(Thermostat):
|
|
"""Sinope Technologies Thermostat."""
|
|
|
|
manufacturer = 0x119C
|
|
update_time_interval = timedelta(minutes=randint(45, 75))
|
|
|
|
def __init__(self, unique_id, zha_device, channels, **kwargs):
|
|
"""Initialize ZHA Thermostat instance."""
|
|
super().__init__(unique_id, zha_device, channels, **kwargs)
|
|
self._presets = [PRESET_AWAY, PRESET_NONE]
|
|
self._supported_flags |= SUPPORT_PRESET_MODE
|
|
self._manufacturer_ch = self.cluster_channels["sinope_manufacturer_specific"]
|
|
|
|
@callback
|
|
def _async_update_time(self, timestamp=None) -> None:
|
|
"""Update thermostat's time display."""
|
|
|
|
secs_2k = (
|
|
dt_util.now().replace(tzinfo=None) - datetime(2000, 1, 1, 0, 0, 0, 0)
|
|
).total_seconds()
|
|
|
|
self.debug("Updating time: %s", secs_2k)
|
|
self._manufacturer_ch.cluster.create_catching_task(
|
|
self._manufacturer_ch.cluster.write_attributes(
|
|
{"secs_since_2k": secs_2k}, manufacturer=self.manufacturer
|
|
)
|
|
)
|
|
|
|
async def async_added_to_hass(self):
|
|
"""Run when about to be added to Hass."""
|
|
await super().async_added_to_hass()
|
|
async_track_time_interval(
|
|
self.hass, self._async_update_time, self.update_time_interval
|
|
)
|
|
self._async_update_time()
|
|
|
|
async def async_preset_handler_away(self, is_away: bool = False) -> bool:
|
|
"""Set occupancy."""
|
|
mfg_code = self._zha_device.manufacturer_code
|
|
res = await self._thrm.write_attributes(
|
|
{"set_occupancy": 0 if is_away else 1}, manufacturer=mfg_code
|
|
)
|
|
|
|
self.debug("set occupancy to %s. Status: %s", 0 if is_away else 1, res)
|
|
return res
|
|
|
|
|
|
@MULTI_MATCH(
|
|
channel_names=CHANNEL_THERMOSTAT,
|
|
aux_channels=CHANNEL_FAN,
|
|
manufacturers="Zen Within",
|
|
stop_on_match=True,
|
|
)
|
|
class ZenWithinThermostat(Thermostat):
|
|
"""Zen Within Thermostat implementation."""
|
|
|
|
@property
|
|
def _rm_rs_action(self) -> str | None:
|
|
"""Return the current HVAC action based on running mode and running state."""
|
|
|
|
if (running_state := self._thrm.running_state) is None:
|
|
return None
|
|
if running_state & (RunningState.HEAT | RunningState.HEAT_STAGE_2):
|
|
return CURRENT_HVAC_HEAT
|
|
if running_state & (RunningState.COOL | RunningState.COOL_STAGE_2):
|
|
return CURRENT_HVAC_COOL
|
|
if running_state & (
|
|
RunningState.FAN | RunningState.FAN_STAGE_2 | RunningState.FAN_STAGE_3
|
|
):
|
|
return CURRENT_HVAC_FAN
|
|
|
|
if self.hvac_mode != HVAC_MODE_OFF:
|
|
return CURRENT_HVAC_IDLE
|
|
return CURRENT_HVAC_OFF
|
|
|
|
|
|
@MULTI_MATCH(
|
|
channel_names=CHANNEL_THERMOSTAT,
|
|
aux_channels=CHANNEL_FAN,
|
|
manufacturers="Centralite",
|
|
models="3157100",
|
|
stop_on_match=True,
|
|
)
|
|
class CentralitePearl(ZenWithinThermostat):
|
|
"""Centralite Pearl Thermostat implementation."""
|
|
|
|
|
|
@STRICT_MATCH(
|
|
channel_names=CHANNEL_THERMOSTAT,
|
|
manufacturers={
|
|
"_TZE200_ckud7u2l",
|
|
"_TZE200_ywdxldoj",
|
|
"_TZE200_cwnjrr72",
|
|
"_TZE200_b6wax7g0",
|
|
"_TYST11_ckud7u2l",
|
|
"_TYST11_ywdxldoj",
|
|
"_TYST11_cwnjrr72",
|
|
"_TYST11_b6wax7g0",
|
|
},
|
|
)
|
|
class MoesThermostat(Thermostat):
|
|
"""Moes Thermostat implementation."""
|
|
|
|
def __init__(self, unique_id, zha_device, channels, **kwargs):
|
|
"""Initialize ZHA Thermostat instance."""
|
|
super().__init__(unique_id, zha_device, channels, **kwargs)
|
|
self._presets = [
|
|
PRESET_NONE,
|
|
PRESET_AWAY,
|
|
PRESET_SCHEDULE,
|
|
PRESET_COMFORT,
|
|
PRESET_ECO,
|
|
PRESET_BOOST,
|
|
PRESET_COMPLEX,
|
|
]
|
|
self._supported_flags |= SUPPORT_PRESET_MODE
|
|
|
|
@property
|
|
def hvac_modes(self) -> tuple[str, ...]:
|
|
"""Return only the heat mode, because the device can't be turned off."""
|
|
return (HVAC_MODE_HEAT,)
|
|
|
|
async def async_attribute_updated(self, record):
|
|
"""Handle attribute update from device."""
|
|
if record.attr_name == "operation_preset":
|
|
if record.value == 0:
|
|
self._preset = PRESET_AWAY
|
|
if record.value == 1:
|
|
self._preset = PRESET_SCHEDULE
|
|
if record.value == 2:
|
|
self._preset = PRESET_NONE
|
|
if record.value == 3:
|
|
self._preset = PRESET_COMFORT
|
|
if record.value == 4:
|
|
self._preset = PRESET_ECO
|
|
if record.value == 5:
|
|
self._preset = PRESET_BOOST
|
|
if record.value == 6:
|
|
self._preset = PRESET_COMPLEX
|
|
await super().async_attribute_updated(record)
|
|
|
|
async def async_preset_handler(self, preset: str, enable: bool = False) -> bool:
|
|
"""Set the preset mode."""
|
|
mfg_code = self._zha_device.manufacturer_code
|
|
if not enable:
|
|
return await self._thrm.write_attributes(
|
|
{"operation_preset": 2}, manufacturer=mfg_code
|
|
)
|
|
if preset == PRESET_AWAY:
|
|
return await self._thrm.write_attributes(
|
|
{"operation_preset": 0}, manufacturer=mfg_code
|
|
)
|
|
if preset == PRESET_SCHEDULE:
|
|
return await self._thrm.write_attributes(
|
|
{"operation_preset": 1}, manufacturer=mfg_code
|
|
)
|
|
if preset == PRESET_COMFORT:
|
|
return await self._thrm.write_attributes(
|
|
{"operation_preset": 3}, manufacturer=mfg_code
|
|
)
|
|
if preset == PRESET_ECO:
|
|
return await self._thrm.write_attributes(
|
|
{"operation_preset": 4}, manufacturer=mfg_code
|
|
)
|
|
if preset == PRESET_BOOST:
|
|
return await self._thrm.write_attributes(
|
|
{"operation_preset": 5}, manufacturer=mfg_code
|
|
)
|
|
if preset == PRESET_COMPLEX:
|
|
return await self._thrm.write_attributes(
|
|
{"operation_preset": 6}, manufacturer=mfg_code
|
|
)
|
|
|
|
return False
|