class DysonPureLinkPlugin:
#define class variables
#plugin version
version = "4.0.3"
enabled = False
mqttClient = None
#unit numbers for devices to create
#for Pure Cool models
fanModeUnit = 1
nightModeUnit = 2
fanSpeedUnit = 3
fanOscillationUnit = 4
standbyMonitoringUnit = 5
filterLifeUnit = 6
qualityTargetUnit = 7
tempHumUnit = 8
volatileUnit = 9
particlesUnit = 10
sleepTimeUnit = 11
fanStateUnit = 12
fanFocusUnit = 13
fanModeAutoUnit = 14
particles2_5Unit = 15
particles10Unit = 16
nitrogenDioxideDensityUnit = 17
heatModeUnit = 18
heatTargetUnit = 19
heatStateUnit = 20
particlesMatter25Unit = 21
particlesMatter10Unit = 22
resetFilterLifeUnit = 23
deviceStatusUnit = 24
runCounter = 6
def __init__(self):
self.myDevice = None
self.password = None
self.ip_address = None
self.port_number = None
self.sensor_data = None
self.state_data = None
self.mqttClient = None
self.log_level = None
def onStart(self):
Domoticz.Debug("onStart called")
#read out parameters for local connection
self.ip_address = Parameters["Address"].strip()
self.port_number = Parameters["Port"].strip()
self.otp_code = Parameters['Mode1']
self.runCounter = int(Parameters['Mode2'])
self.log_level = Parameters['Mode4']
self.account_password = Parameters['Mode3']
self.account_email = Parameters['Mode5']
self.machine_name = Parameters['Mode6']
if self.log_level == 'Debug':
Domoticz.Debugging(2)
DumpConfigToLog()
if self.log_level == 'Verbose':
Domoticz.Debugging(1 + 2 + 4 + 8 + 16 + 64)
DumpConfigToLog()
if self.log_level == 'Reset':
Domoticz.Log(
"Plugin config will be erased to retreive new cloud account data"
)
Config = {}
Config = Domoticz.Configuration(Config)
#PureLink needs polling, get from config
Domoticz.Heartbeat(10)
self.checkVersion(self.version)
mqtt_client_id = ""
#create a Dyson account
deviceList = self.get_device_names()
if deviceList != None and len(deviceList) > 0:
Domoticz.Debug(
"Number of devices found in plugin configuration: '" +
str(len(deviceList)) + "'")
else:
Domoticz.Log(
"No devices found in plugin configuration, request from Dyson cloud account"
)
#new authentication
Domoticz.Debug(
"=== start making connection to Dyson account, new method as of 2021 ==="
)
dysonAccount2 = DysonAccount()
challenge_id = getConfigItem(Key="challenge_id", Default="")
setConfigItem(Key="challenge_id", Value="") #clear after use
if challenge_id == "":
#request otp code via email when no code entered
challenge_id = dysonAccount2.login_email_otp(
self.account_email, "NL")
setConfigItem(Key="challenge_id", Value=challenge_id)
Domoticz.Log(
'==== An OTP verification code had been requested, please check email and paste code into plugin====='
)
return
else:
#verify the received code
if len(self.otp_code) < 6:
Domoticz.Error("invalid verification code supplied")
return
dysonAccount2.verify(self.otp_code, self.account_email,
self.account_password, challenge_id)
setConfigItem(
Key="challenge_id",
Value="") #reset challenge id as it is no longer valid
Parameters['Mode1'] = "0" #reset the stored otp code
#get list of devices info's
deviceList = dysonAccount2.devices()
deviceNames = list(deviceList.keys())
Domoticz.Log("Received new devices: " + str(deviceNames) +
", they will be stored in plugin configuration")
i = 0
for device in deviceList:
setConfigItem(
Key="{0}.name".format(i),
Value=deviceNames[i]) #store the name of the machine
Domoticz.Debug('Key="{0}.name", Value = {1}'.format(
i, deviceNames[i])) #store the name of the machine
setConfigItem(
Key="{0}.credential".format(
deviceList[deviceNames[i]].name),
Value=deviceList[
deviceNames[i]].credential) #store the credential
Domoticz.Debug('Key="{0}.credential", Value = {1}'.format(
deviceList[deviceNames[i]].name, deviceList[
deviceNames[i]].credential)) #store the credential
setConfigItem(
Key="{0}.serial".format(
deviceList[deviceNames[i]].name),
Value=deviceList[
deviceNames[i]].serial) #store the serial
Domoticz.Debug('Key="{0}.serial", Value = {1}'.format(
deviceList[deviceNames[i]].name,
deviceList[deviceNames[i]].serial)) #store the serial
setConfigItem(Key="{0}.product_type".format(
deviceList[deviceNames[i]].name),
Value=deviceList[deviceNames[i]].product_type
) #store the product_type
Domoticz.Debug(
'Key="{0}.product_type" , Value = {1}'.format(
deviceList[deviceNames[i]].name,
deviceList[deviceNames[i]].product_type)
) #store the product_type
i = i + 1
if deviceList == None or len(deviceList) < 1:
Domoticz.Error(
"No devices found in plugin configuration or Dyson cloud account"
)
return
else:
Domoticz.Debug("Number of devices in plugin: '" +
str(len(deviceList)) + "'")
if deviceList != None and len(deviceList) > 0:
if len(self.machine_name) > 0:
if self.machine_name in deviceList:
password, serialNumber, deviceType = self.get_device_config(
self.machine_name)
Domoticz.Debug(
"password: {0}, serialNumber: {1}, deviceType: {2}".
format(password, serialNumber, deviceType))
self.myDevice = DysonPureLinkDevice(
password, serialNumber, deviceType, self.machine_name)
else:
Domoticz.Error(
"The configured device name '" + self.machine_name +
"' was not found in the cloud account. Available options: "
+ str(list(deviceList)))
return
elif len(deviceList) == 1:
self.myDevice = deviceList[list(deviceList)[0]]
Domoticz.Log(
"1 device found in plugin, none configured, assuming we need this one: '"
+ self.myDevice.name + "'")
else:
#more than 1 device returned in cloud and no name configured, which the the plugin can't handle
Domoticz.Error(
"More than 1 device found in cloud account but no device name given to select. Select and filter one from available options: "
+ str(list(deviceList)))
return
#the Domoticz connection object takes username and pwd from the Parameters so write them back
Parameters[
'Username'] = self.myDevice.serial #take username from account
Parameters[
'Password'] = self.myDevice.password #override the default password with the one returned from the cloud
else:
Domoticz.Error("No usable credentials found")
return
#check, per device, if it is created. If not,create it
Options = {
"LevelActions": "|||",
"LevelNames": "|OFF|ON|AUTO",
"LevelOffHidden": "true",
"SelectorStyle": "1"
}
if self.fanModeUnit not in Devices:
Domoticz.Device(Name='Fan mode',
Unit=self.fanModeUnit,
TypeName="Selector Switch",
Image=7,
Options=Options).Create()
if self.fanStateUnit not in Devices:
Domoticz.Device(Name='Fan state',
Unit=self.fanStateUnit,
Type=244,
Subtype=62,
Image=7,
Switchtype=0).Create()
if self.heatStateUnit not in Devices:
Domoticz.Device(Name='Heating state',
Unit=self.heatStateUnit,
Type=244,
Subtype=62,
Image=7,
Switchtype=0).Create()
if self.nightModeUnit not in Devices:
Domoticz.Device(Name='Night mode',
Unit=self.nightModeUnit,
Type=244,
Subtype=62,
Switchtype=0,
Image=9).Create()
Options = {
"LevelActions": "|||||||||||",
"LevelNames": "OFF|1|2|3|4|5|6|7|8|9|10|AUTO",
"LevelOffHidden": "false",
"SelectorStyle": "1"
}
if self.fanSpeedUnit not in Devices:
Domoticz.Device(Name='Fan speed',
Unit=self.fanSpeedUnit,
TypeName="Selector Switch",
Image=7,
Options=Options).Create()
if self.fanOscillationUnit not in Devices:
Domoticz.Device(Name='Oscilation mode',
Unit=self.fanOscillationUnit,
Type=244,
Subtype=62,
Image=7,
Switchtype=0).Create()
if self.standbyMonitoringUnit not in Devices:
Domoticz.Device(Name='Standby monitor',
Unit=self.standbyMonitoringUnit,
Type=244,
Subtype=62,
Image=7,
Switchtype=0).Create()
if self.filterLifeUnit not in Devices:
Options: {'Custom': '1;hrs'}
Domoticz.Device(Name='Remaining filter life',
Unit=self.filterLifeUnit,
TypeName="Custom",
Options=Options).Create()
if self.resetFilterLifeUnit not in Devices:
Domoticz.Device(Name='Reset filter: 0 hrs',
Unit=self.resetFilterLifeUnit,
TypeName="Switch",
Image=9).Create()
if self.tempHumUnit not in Devices:
Domoticz.Device(Name='Temperature and Humidity',
Unit=self.tempHumUnit,
TypeName="Temp+Hum").Create()
if self.volatileUnit not in Devices:
Domoticz.Device(Name='Volatile organic',
Unit=self.volatileUnit,
TypeName="Air Quality").Create()
if self.sleepTimeUnit not in Devices:
Domoticz.Device(Name='Sleep timer',
Unit=self.sleepTimeUnit,
TypeName="Custom").Create()
if self.particlesUnit not in Devices:
Domoticz.Device(Name='Dust',
Unit=self.particlesUnit,
TypeName="Air Quality").Create()
if self.qualityTargetUnit not in Devices:
Options = {
"LevelActions": "|||",
"LevelNames":
"|Normal|Sensitive (Medium)|Very Sensitive (High)|Off",
"LevelOffHidden": "true",
"SelectorStyle": "1"
}
Domoticz.Device(Name='Air quality setpoint',
Unit=self.qualityTargetUnit,
TypeName="Selector Switch",
Image=7,
Options=Options).Create()
if self.particles2_5Unit not in Devices:
Domoticz.Device(Name='Dust (PM 2,5)',
Unit=self.particles2_5Unit,
TypeName="Air Quality").Create()
if self.particles10Unit not in Devices:
Domoticz.Device(Name='Dust (PM 10)',
Unit=self.particles10Unit,
TypeName="Air Quality").Create()
if self.particlesMatter25Unit not in Devices:
Domoticz.Device(Name='Particles (PM 25)',
Unit=self.particlesMatter25Unit,
TypeName="Air Quality").Create()
if self.particlesMatter10Unit not in Devices:
Domoticz.Device(Name='Particles (PM 10)',
Unit=self.particlesMatter10Unit,
TypeName="Air Quality").Create()
if self.fanModeAutoUnit not in Devices:
Domoticz.Device(Name='Fan mode auto',
Unit=self.fanModeAutoUnit,
Type=244,
Subtype=62,
Image=7,
Switchtype=0).Create()
if self.fanFocusUnit not in Devices:
Domoticz.Device(Name='Fan focus mode',
Unit=self.fanFocusUnit,
Type=244,
Subtype=62,
Image=7,
Switchtype=0).Create()
if self.nitrogenDioxideDensityUnit not in Devices:
Domoticz.Device(Name='Nitrogen Dioxide Density (NOx)',
Unit=self.nitrogenDioxideDensityUnit,
TypeName="Air Quality").Create()
if self.heatModeUnit not in Devices:
Options = {
"LevelActions": "||",
"LevelNames": "|Off|Heating",
"LevelOffHidden": "true",
"SelectorStyle": "1"
}
Domoticz.Device(Name='Heat mode',
Unit=self.heatModeUnit,
TypeName="Selector Switch",
Image=7,
Options=Options).Create()
if self.heatTargetUnit not in Devices:
Domoticz.Device(Name='Heat target',
Unit=self.heatTargetUnit,
Type=242,
Subtype=1).Create()
if self.deviceStatusUnit not in Devices:
Domoticz.Device(Name='Machine status',
Unit=self.deviceStatusUnit,
TypeName="Text",
Image=7).Create()
Domoticz.Log("Device instance created: " + str(self.myDevice))
self.base_topic = self.myDevice.device_base_topic
Domoticz.Debug("base topic defined: '" + self.base_topic + "'")
#create the connection
if self.myDevice != None:
self.mqttClient = MqttClient(self.ip_address, self.port_number,
mqtt_client_id, self.onMQTTConnected,
self.onMQTTDisconnected,
self.onMQTTPublish,
self.onMQTTSubscribed)
def onStop(self):
Domoticz.Debug("onStop called")
def onCommand(self, Unit, Command, Level, Hue):
Domoticz.Debug("DysonPureLink plugin: onCommand called for Unit " +
str(Unit) + ": Parameter '" + str(Command) +
"', Level: " + str(Level))
topic = ''
payload = ''
arg = ''
fan_pwr_list = ['438', '520', '527']
if Unit == self.qualityTargetUnit and Level <= 100:
topic, payload = self.myDevice.set_quality_target(Level)
if Unit == self.fanSpeedUnit and Level <= 100:
arg = "0000" + str(Level // 10)
topic, payload = self.myDevice.set_fan_speed(
arg[-4:]) #use last 4 characters as speed level or AUTO
self.mqttClient.Publish(topic, payload)
if Level > 0:
#when setting a speed value, make sure that the fan is actually on
if self.myDevice.product_type in fan_pwr_list:
topic, payload = self.myDevice.set_fan_power("ON")
else:
topic, payload = self.myDevice.set_fan_mode("FAN")
else:
if self.myDevice.product_type in fan_pwr_list:
topic, payload = self.myDevice.set_fan_power("OFF")
else:
topic, payload = self.myDevice.set_fan_mode(
"OFF") #use last 4 characters as speed level or AUTO
if Unit == self.fanModeUnit or (Unit == self.fanSpeedUnit
and Level > 100):
if self.myDevice.product_type in fan_pwr_list:
if Level >= 30:
arg = "ON"
#Switch to Auto
topic, payload = self.myDevice.set_fan_power(arg)
self.mqttClient.Publish(topic, payload)
topic, payload = self.myDevice.set_fan_mode_auto(arg)
elif Level == 20:
arg = "ON"
#Switch on, auto depends on previous setting
topic, payload = self.myDevice.set_fan_power(arg)
else:
#Switch Off
arg = 'OFF'
topic, payload = self.myDevice.set_fan_power(arg)
else:
if Level == 10: arg = "OFF"
if Level == 20: arg = "FAN"
if Level >= 30: arg = "AUTO"
topic, payload = self.myDevice.set_fan_mode(arg)
if Unit == self.fanStateUnit:
Domoticz.Log("Unit Fans State is read only, no command sent")
if Unit == self.fanOscillationUnit:
topic, payload = self.myDevice.set_oscilation(str(Command).upper())
if Unit == self.fanFocusUnit:
topic, payload = self.myDevice.set_focus(str(Command).upper())
if Unit == self.fanModeAutoUnit:
topic, payload = self.myDevice.set_fan_mode_auto(
str(Command).upper())
if Unit == self.standbyMonitoringUnit:
topic, payload = self.myDevice.set_standby_monitoring(
str(Command).upper())
if Unit == self.nightModeUnit:
topic, payload = self.myDevice.set_night_mode(str(Command).upper())
if Unit == self.heatModeUnit:
if Level == 10: arg = "OFF"
if Level == 20: arg = "HEAT"
topic, payload = self.myDevice.set_heat_mode(arg)
if Unit == self.heatTargetUnit:
topic, payload = self.myDevice.set_heat_target(Level)
if Unit == self.resetFilterLifeUnit:
UpdateDevice(self.resetFilterLifeUnit, 1,
"On") #acknowlegde switching on
topic, payload = self.myDevice.reset_filter()
self.mqttClient.Publish(topic, payload)
def onConnect(self, Connection, Status, Description):
Domoticz.Debug("onConnect called: Connection '" + str(Connection) +
"', Status: '" + str(Status) + "', Description: '" +
Description + "'")
self.mqttClient.onConnect(Connection, Status, Description)
def onDisconnect(self, Connection):
self.mqttClient.onDisconnect(Connection)
def onMessage(self, Connection, Data):
self.mqttClient.onMessage(Connection, Data)
def onNotification(self, Name, Subject, Text, Status, Priority, Sound,
ImageFile):
Domoticz.Log("DysonPureLink plugin: onNotification: " + Name + "," +
Subject + "," + Text + "," + Status + "," +
str(Priority) + "," + Sound + "," + ImageFile)
def onHeartbeat(self):
if self.myDevice != None:
self.runCounter = self.runCounter - 1
if self.runCounter <= 0:
Domoticz.Debug("DysonPureLink plugin: Poll unit")
self.runCounter = int(Parameters['Mode2'])
topic, payload = self.myDevice.request_state()
self.mqttClient.Publish(
topic, payload) #ask for update of current status
else:
Domoticz.Debug("Polling unit in " + str(self.runCounter) +
" heartbeats.")
self.mqttClient.onHeartbeat()
def onDeviceRemoved(self, unit):
Domoticz.Log(
"DysonPureLink plugin: onDeviceRemoved called for unit '" +
str(unit) + "'")
def updateDevices(self):
"""Update the defined devices from incoming mesage info"""
#update the devices
if self.state_data.oscillation is not None:
UpdateDevice(self.fanOscillationUnit,
self.state_data.oscillation.state,
str(self.state_data.oscillation))
if self.state_data.night_mode is not None:
UpdateDevice(self.nightModeUnit, self.state_data.night_mode.state,
str(self.state_data.night_mode))
# Fan speed
if self.state_data.fan_speed is not None:
f_rate = self.state_data.fan_speed
if (f_rate == "AUTO"):
nValueNew = 110
sValueNew = "110" # Auto
else:
nValueNew = (int(f_rate)) * 10
sValueNew = str((int(f_rate)) * 10)
if self.state_data.fan_mode is not None:
Domoticz.Debug("update fanspeed, state of FanMode: " +
str(self.state_data.fan_mode))
if self.state_data.fan_mode.state == 0:
nValueNew = 0
sValueNew = "0"
UpdateDevice(self.fanSpeedUnit, nValueNew, sValueNew)
if self.state_data.fan_mode is not None:
UpdateDevice(self.fanModeUnit, self.state_data.fan_mode.state,
str((self.state_data.fan_mode.state + 1) * 10))
if self.state_data.fan_state is not None:
UpdateDevice(self.fanStateUnit, self.state_data.fan_state.state,
str((self.state_data.fan_state.state + 1) * 10))
if self.state_data.filter_life is not None:
UpdateDevice(self.filterLifeUnit, self.state_data.filter_life,
str(self.state_data.filter_life))
if self.state_data.filter_life is not None:
nameBase, curValue = Devices[self.resetFilterLifeUnit].Name.split(
":")
UpdateDevice(self.resetFilterLifeUnit,
0,
"Off",
Name=nameBase + ": " +
str(self.state_data.filter_life) + " hrs")
if self.state_data.quality_target is not None:
UpdateDevice(self.qualityTargetUnit,
self.state_data.quality_target.state,
str((self.state_data.quality_target.state + 1) * 10))
if self.state_data.standby_monitoring is not None:
UpdateDevice(
self.standbyMonitoringUnit,
self.state_data.standby_monitoring.state,
str((self.state_data.standby_monitoring.state + 1) * 10))
if self.state_data.fan_mode_auto is not None:
UpdateDevice(self.fanModeAutoUnit,
self.state_data.fan_mode_auto.state,
str((self.state_data.fan_mode_auto.state + 1) * 10))
if self.state_data.focus is not None:
UpdateDevice(self.fanFocusUnit, self.state_data.focus.state,
str(self.state_data.focus))
if self.state_data.heat_mode is not None:
UpdateDevice(self.heatModeUnit, self.state_data.heat_mode.state,
str((self.state_data.heat_mode.state + 1) * 10))
if self.state_data.heat_target is not None:
UpdateDevice(self.heatTargetUnit, 0,
str(self.state_data.heat_target))
if self.state_data.heat_state is not None:
UpdateDevice(self.heatStateUnit, self.state_data.heat_state.state,
str((self.state_data.heat_state.state + 1) * 10))
if self.state_data.error is not None and self.state_data.warning is not None:
status_string = "Error: {}<br> Warning: {}".format(
self.state_data.error, self.state_data.warning)
UpdateDevice(self.deviceStatusUnit, 0, status_string)
Domoticz.Debug("update StateData: " + str(self.state_data))
def updateSensors(self):
"""Update the defined devices from incoming mesage info"""
#update the devices
if self.sensor_data.temperature is not None and self.sensor_data.humidity is not None:
tempNum = int(self.sensor_data.temperature)
humNum = int(self.sensor_data.humidity)
UpdateDevice(
self.tempHumUnit, 1,
str(self.sensor_data.temperature)[:4] + ';' +
str(self.sensor_data.humidity) + ";1")
if self.sensor_data.volatile_compounds is not None:
UpdateDevice(self.volatileUnit,
self.sensor_data.volatile_compounds,
str(self.sensor_data.volatile_compounds))
if self.sensor_data.particles is not None:
UpdateDevice(self.particlesUnit, self.sensor_data.particles,
str(self.sensor_data.particles))
if self.sensor_data.particles2_5 is not None:
UpdateDevice(self.particles2_5Unit, self.sensor_data.particles2_5,
str(self.sensor_data.particles2_5))
if self.sensor_data.particles10 is not None:
UpdateDevice(self.particles10Unit, self.sensor_data.particles10,
str(self.sensor_data.particles10))
if self.sensor_data.particulate_matter_25 is not None:
UpdateDevice(self.particlesMatter25Unit,
self.sensor_data.particulate_matter_25,
str(self.sensor_data.particulate_matter_25))
if self.sensor_data.particulate_matter_10 is not None:
UpdateDevice(self.particlesMatter10Unit,
self.sensor_data.particulate_matter_10,
str(self.sensor_data.particulate_matter_10))
if self.sensor_data.nitrogenDioxideDensity is not None:
UpdateDevice(self.nitrogenDioxideDensityUnit,
self.sensor_data.nitrogenDioxideDensity,
str(self.sensor_data.nitrogenDioxideDensity))
if self.sensor_data.heat_target is not None:
UpdateDevice(self.heatTargetUnit, self.sensor_data.heat_target,
str(self.sensor_data.heat_target))
UpdateDevice(self.sleepTimeUnit, self.sensor_data.sleep_timer,
str(self.sensor_data.sleep_timer))
if self.sensor_data.has_data:
Domoticz.Debug("update SensorData: " + str(self.sensor_data))
else:
Domoticz.Debug("partial SensorData to update")
def onMQTTConnected(self):
"""connection to device established"""
Domoticz.Debug("onMQTTConnected called")
Domoticz.Log("MQTT connection established")
self.mqttClient.Subscribe([
self.base_topic + '/status/current',
self.base_topic + '/status/connection',
self.base_topic + '/status/faults'
]) #subscribe to all topics on the machine
topic, payload = self.myDevice.request_state()
self.mqttClient.Publish(topic,
payload) #ask for update of current status
def onMQTTDisconnected(self):
Domoticz.Debug("onMQTTDisconnected")
def onMQTTSubscribed(self):
Domoticz.Debug("onMQTTSubscribed")
def onMQTTPublish(self, topic, message):
Domoticz.Debug("MQTT Publish: MQTT message incoming: " + topic + " " +
str(message))
if (topic == self.base_topic + '/status/current'):
#update of the machine's status
if StateData.is_state_data(message):
Domoticz.Debug("machine state or state change recieved")
self.state_data = StateData(message)
self.updateDevices()
if SensorsData.is_sensors_data(message):
Domoticz.Debug("sensor state recieved")
self.sensor_data = SensorsData(message)
self.updateSensors()
if (topic == self.base_topic + '/status/connection'):
#connection status received
Domoticz.Debug("connection state recieved")
if (topic == self.base_topic + '/status/software'):
#connection status received
Domoticz.Debug("software state recieved")
if (topic == self.base_topic + '/status/summary'):
#connection status received
Domoticz.Debug("summary state recieved")
def checkVersion(self, version):
"""checks actual version against stored version as 'Ma.Mi.Pa' and checks if updates needed"""
#read version from stored configuration
ConfVersion = getConfigItem("plugin version", "0.0.0")
Domoticz.Log("Starting version: " + version)
MaCurrent, MiCurrent, PaCurrent = version.split('.')
MaConf, MiConf, PaConf = ConfVersion.split('.')
Domoticz.Debug("checking versions: current '{0}', config '{1}'".format(
version, ConfVersion))
if int(MaConf) < int(MaCurrent):
Domoticz.Log("Major version upgrade: {0} -> {1}".format(
MaConf, MaCurrent))
#add code to perform MAJOR upgrades
elif int(MiConf) < int(MiCurrent):
Domoticz.Log("Minor version upgrade: {0} -> {1}".format(
MiConf, MiCurrent))
#add code to perform MINOR upgrades
elif int(PaConf) < int(PaCurrent):
Domoticz.Log("Patch version upgrade: {0} -> {1}".format(
PaConf, PaCurrent))
#add code to perform PATCH upgrades, if any
if ConfVersion != version:
#store new version info
self._setVersion(MaCurrent, MiCurrent, PaCurrent)
def get_device_names(self):
"""find the amount of stored devices"""
Configurations = getConfigItem()
devices = {}
for x in Configurations:
if x.find(".") > -1 and x.split(".")[1] == "name":
devices[str(Configurations[x])] = str(Configurations[x])
return devices
def get_device_config(self, name):
"""fetch all relevant config items from Domoticz.Configuration for device with name"""
Configurations = getConfigItem()
for x in Configurations:
if x.split(".")[1] == "name":
Domoticz.Debug("Found a machine name: " + x + " value: '" +
str(Configurations[x]) + "'")
if Configurations[x] == name:
password = getConfigItem(
Key="{0}.{1}".format(name, "credential"))
serialNumber = getConfigItem(
Key="{0}.{1}".format(name, "serial"))
deviceType = getConfigItem(
Key="{0}.{1}".format(name, "product_type"))
return password, serialNumber, deviceType
return
def _setVersion(self, major, minor, patch):
#set configs
Domoticz.Debug("Setting version to {0}.{1}.{2}".format(
major, minor, patch))
setConfigItem(Key="MajorVersion", Value=major)
setConfigItem(Key="MinorVersion", Value=minor)
setConfigItem(Key="patchVersion", Value=patch)
setConfigItem(Key="plugin version",
Value="{0}.{1}.{2}".format(major, minor, patch))
def _storeCredentials(self, creds, auths):
#store credentials as config item
Domoticz.Debug("Storing credentials: " + str(creds) +
" and auth object: " + str(auths))
currentCreds = getConfigItem(Key="credentials", Default=None)
if currentCreds is None or currentCreds != creds:
Domoticz.Log(
"Credentials from user authentication do not match those stored in config, updating config"
)
setConfigItem(Key="credentials", Value=creds)
return True
class BasePlugin:
mqttClient = None
def onStart(self):
self.debugging = Parameters["Mode6"]
if self.debugging == "Verbose+":
Domoticz.Debugging(2 + 4 + 8 + 16 + 64)
if self.debugging == "Verbose":
Domoticz.Debugging(2 + 4 + 8 + 16 + 64)
if self.debugging == "Debug":
Domoticz.Debugging(2 + 4 + 8)
self.controller = EmsDevices()
self.controller.checkDevices()
self.topics = list([
"home/ems-esp/thermostat_data", "home/ems-esp/boiler_data",
"home/ems-esp/STATE"
])
self.mqttserveraddress = Parameters["Address"].replace(" ", "")
self.mqttserverport = Parameters["Port"].replace(" ", "")
self.mqttClient = MqttClient(self.mqttserveraddress,
self.mqttserverport, self.onMQTTConnected,
self.onMQTTDisconnected,
self.onMQTTPublish, self.onMQTTSubscribed)
def checkDevices(self):
Domoticz.Log("checkDevices called")
def onStop(self):
Domoticz.Log("onStop called")
def onCommand(self, Unit, Command, Level, Color):
Domoticz.Debug("Command: " + Command + " (" + str(Level))
self.controller.onCommand(self.mqttClient, Unit, Command, Level, Color)
def onConnect(self, Connection, Status, Description):
self.mqttClient.onConnect(Connection, Status, Description)
def onDisconnect(self, Connection):
self.mqttClient.onDisconnect(Connection)
def onMessage(self, Connection, Data):
self.mqttClient.onMessage(Connection, Data)
def onHeartbeat(self):
Domoticz.Debug("Heartbeating...")
# Reconnect if connection has dropped
if self.mqttClient.mqttConn is None or (
not self.mqttClient.mqttConn.Connecting()
and not self.mqttClient.mqttConn.Connected()
or not self.mqttClient.isConnected):
Domoticz.Debug("Reconnecting")
self.mqttClient.Open()
else:
self.mqttClient.Ping()
def onMQTTConnected(self):
Domoticz.Debug("onMQTTConnected")
self.mqttClient.Subscribe(self.topics)
def onMQTTDisconnected(self):
Domoticz.Debug("onMQTTDisconnected")
def onMQTTSubscribed(self):
Domoticz.Debug("onMQTTSubscribed")
def onMQTTPublish(self, topic, rawmessage):
Domoticz.Debug("MQTT message: " + topic + " " + str(rawmessage))
message = ""
try:
message = json.loads(rawmessage.decode('utf8'))
except ValueError:
message = rawmessage.decode('utf8')
if (topic in self.topics):
self.controller.onMqttMessage(topic, message)
class BasePlugin:
mqttClient = None
def onStart(self):
self.debugging = Parameters["Mode6"]
if self.debugging == "Verbose":
Domoticz.Debugging(2+4+8+16+64)
if self.debugging == "Debug":
Domoticz.Debugging(2)
Domoticz.Debug("onStart called")
self.base_topic = Parameters["Mode1"].strip()
self.pairing_enabled = True if Parameters["Mode2"] == 'true' else False
self.subscribed_for_devices = False
mqtt_server_address = Parameters["Address"].strip()
mqtt_server_port = Parameters["Port"].strip()
mqtt_client_id = Parameters["Mode3"].strip()
self.mqttClient = MqttClient(mqtt_server_address, mqtt_server_port, mqtt_client_id, self.onMQTTConnected, self.onMQTTDisconnected, self.onMQTTPublish, self.onMQTTSubscribed)
self.available_devices = DeviceStorage.getInstance()
def checkDevices(self):
Domoticz.Debug("checkDevices called")
def onStop(self):
Domoticz.Debug("onStop called")
def handlePairingMode(self):
if (self.pairing_enabled):
self.mqttClient.Publish(self.base_topic + '/bridge/config/permit_join', 'true')
Domoticz.Log("Joining new devices is enabled on the zigbee bridge")
else:
self.mqttClient.Publish(self.base_topic + '/bridge/config/permit_join', 'false')
Domoticz.Log("Joining new devices is disabled on the zigbee bridge")
def onCommand(self, Unit, Command, Level, Color):
Domoticz.Debug("onCommand: " + Command + ", level (" + str(Level) + ") Color:" + Color)
device = Devices[Unit] #Devices is Domoticz collection of devices for this hardware
device_params = device.DeviceID.split('_')
device_id = device_params[0]
alias = device_params[1]
device_data = self.available_devices.get_device_by_id(device_id)
if (device_data == None):
Domoticz.Log('Device ' + device.Name + ' does not have registered zigbee2mqtt device')
return
model = device_data['model']
if (model in adapter_by_model):
adapter = adapter_by_model[model](Devices)
message = adapter.handleCommand(alias, device, device_data, Command, Level, Color)
if (message != None):
self.mqttClient.Publish(self.base_topic + '/' + message['topic'], message['payload'])
else:
Domoticz.Log('Device ' + device.Name + ' does not have adapter (model: "' + model + '"')
def onConnect(self, Connection, Status, Description):
Domoticz.Debug("onConnect called")
self.mqttClient.onConnect(Connection, Status, Description)
def onDisconnect(self, Connection):
self.mqttClient.onDisconnect(Connection)
def onMessage(self, Connection, Data):
self.mqttClient.onMessage(Connection, Data)
def onHeartbeat(self):
self.mqttClient.onHeartbeat()
def onMQTTConnected(self):
self.mqttClient.Subscribe([self.base_topic + '/bridge/#'])
def onMQTTDisconnected(self):
Domoticz.Debug("onMQTTDisconnected")
def onMQTTSubscribed(self):
Domoticz.Debug("onMQTTSubscribed")
def onMQTTPublish(self, topic, message):
Domoticz.Debug("MQTT message: " + topic + " " + str(message))
if (topic == self.base_topic + '/bridge/state'):
Domoticz.Log('Zigbee2mqtt bridge is ' + message)
if message == 'online':
self.mqttClient.Publish(self.base_topic + '/bridge/config/devices', '')
self.handlePairingMode()
return
if (topic == self.base_topic + '/bridge/log'):
if message['type'] == 'devices':
Domoticz.Log('Received available devices list from bridge')
self.available_devices.update(Devices, message['message'])
if self.subscribed_for_devices == False:
self.mqttClient.Subscribe([self.base_topic + '/+'])
self.subscribed_for_devices = True
return
device_name = topic.replace(self.base_topic + "/", "")
device_data = self.available_devices.get_device_by_name(device_name)
if (device_data != None):
model = device_data['model']
if (model in adapter_by_model):
zigbee_message = ZigbeeMessage(message)
adapter = adapter_by_model[model](Devices)
adapter.handleMqttMessage(device_data, zigbee_message)
else:
Domoticz.Debug('Unsupported zigbee device type with model "' + model + '"')
else:
Domoticz.Debug('Unhandled message from zigbee2mqtt: ' + topic + ' ' + str(message))
class BasePlugin:
HEARTBEAT_SEC = 10
def __init__(self):
self.mqttClient = None
self.myroomba = None
self.state = None
self.batpct = None
self.execute = None
self.MqttUpdatereceived = False
self.lastMqttUpdate = datetime.now()
return
def onStart(self):
# Debugging On/Off
self.debug = _DEBUG_ON if Parameters["Mode6"] == "Debug" else _DEBUG_OFF
Domoticz.Debugging(self.debug)
# Create images if necessary
if _IMAGE_ROOMBA not in Images:
Domoticz.Image("Roomba.zip").Create()
# Create devices (USED BY DEFAULT)
CreateDevicesUsed()
TimeoutDevice(All=True)
# Create devices (NOT USED BY DEFAULT)
CreateDevicesNotUsed()
# Global settings
DumpConfigToLog()
# Start MQTT
try:
self.mqttClient = MqttClient('localhost', '1883',
self.onMQTTConnected,
self.onMQTTDisconnected,
self.onMQTTPublish,
self.onMQTTSubscribed)
except Exception as e:
Domoticz.Error("MQTT client start error: " + str(e))
self.mqttClient = None
def onStop(self):
Domoticz.Debug("onStop called")
def onCommand(self, Unit, Command, Level,
Color): # react to commands arrived from Domoticz
Domoticz.Debug("Command: " + Command + " (" + str(Level) + ") Color:" +
Color)
if Unit == _UNIT_RUNNING:
if Command == 'On':
if self.state == 'Charging':
self.mqttClient.Publish(_COMMANDS, 'start')
else:
self.mqttClient.Publish(_COMMANDS, 'dock')
else:
self.mqttClient.Publish(_COMMANDS, 'stop')
self.execute = _DOCK
def onConnect(self, Connection, Status, Description):
Domoticz.Debug("Connection: " + str(Status))
if self.mqttClient is not None:
self.mqttClient.onConnect(Connection, Status, Description)
def onDisconnect(self, Connection):
if self.mqttClient is not None:
self.mqttClient.onDisconnect(Connection)
def onMessage(self, Connection, Data):
if self.mqttClient is not None:
self.mqttClient.onMessage(Connection, Data)
def onHeartbeat(self):
Domoticz.Debug("Heartbeating...")
if self.mqttClient is not None:
try:
# Reconnect if connection has dropped
if self.mqttClient.mqttConn is None or (
not self.mqttClient.mqttConn.Connecting()
and not self.mqttClient.mqttConn.Connected()
or not self.mqttClient.isConnected):
Domoticz.Debug("Reconnecting")
self.mqttClient.Open()
else:
self.mqttClient.Ping()
# Commands to Roomba
if self.execute == _DOCK:
if self.state == 'Stopped':
self.mqttClient.Publish(_COMMANDS, 'dock')
if self.state == 'Charging':
self.execute = None
except Exception as e:
Domoticz.Error("onHeartbeat: " + str(e))
# Update devices
if self.MqttUpdatereceived:
if self.state:
UpdateDevice(_UNIT_STATE, 0, self.state,
Images[_IMAGE_ROOMBA].ID)
if self.state == 'Running':
UpdateDevice(_UNIT_RUNNING, 1, 1, Images[_IMAGE_ROOMBA].ID)
else:
UpdateDevice(_UNIT_RUNNING, 0, 0, Images[_IMAGE_ROOMBA].ID)
if self.batpct:
UpdateDeviceBatSig(_UNIT_RUNNING, self.batpct)
UpdateDevice(_UNIT_BAT, self.batpct, self.batpct,
Images[_IMAGE_ROOMBA].ID)
self.MqttUpdatereceived = False
# Check if getting information from MQTT Broker
if (datetime.now() - self.lastMqttUpdate).total_seconds() > int(
Parameters["Mode5"]) * 60:
TimeoutDevice(All=True)
def onMQTTConnected(self):
Domoticz.Debug("onMQTTConnected")
if self.mqttClient is not None:
self.mqttClient.Subscribe([_STATE, _BATPCT])
def onMQTTDisconnected(self):
Domoticz.Debug("onMQTTDisconnected")
def onMQTTSubscribed(self):
Domoticz.Debug("onMQTTSubscribed")
def onMQTTPublish(self, topic, message): # process incoming MQTT statuses
message = message.decode('utf-8')
Domoticz.Debug("MQTT message: " + topic + " " + message)
if topic == _STATE:
self.state = message
self.lastMqttUpdate = datetime.now()
self.MqttUpdatereceived = True
if topic == _BATPCT:
self.batpct = int(message)
self.lastMqttUpdate = datetime.now()
self.MqttUpdatereceived = True
class DysonPureLinkPlugin:
#define class variables
enabled = False
mqttClient = None
#unit numbers for devices to create
#for Pure Cool models
fanModeUnit = 1
nightModeUnit = 2
fanSpeedUnit = 3
fanOscillationUnit = 4
standbyMonitoringUnit = 5
filterLifeUnit = 6
qualityTargetUnit = 7
tempHumUnit = 8
volatileUnit = 9
particlesUnit = 10
sleepTimeUnit = 11
fanStateUnit = 12
fanFocusUnit = 13
fanModeAutoUnit = 14
particles2_5Unit = 15
particles10Unit = 16
nitrogenDioxideDensityUnit = 17
runCounter = 6
def __init__(self):
self.myDevice = None
self.password = None
self.ip_address = None
self.port_number = None
self.sensor_data = None
self.state_data = None
self.mqttClient = None
def onStart(self):
Domoticz.Log("onStart called")
if Parameters['Mode4'] == 'Debug':
Domoticz.Debugging(2)
DumpConfigToLog()
if Parameters['Mode4'] == 'Verbose':
Domoticz.Debugging(1 + 2 + 4 + 8 + 16 + 64)
DumpConfigToLog()
#PureLink needs polling, get from config
Domoticz.Heartbeat(10)
#check, per device, if it is created. If not,create it
Options = {
"LevelActions": "|||",
"LevelNames": "|OFF|ON|AUTO",
"LevelOffHidden": "true",
"SelectorStyle": "1"
}
if self.fanModeUnit not in Devices:
Domoticz.Device(Name='Fan mode',
Unit=self.fanModeUnit,
TypeName="Selector Switch",
Image=7,
Options=Options).Create()
Options = {
"LevelActions": "||",
"LevelNames": "|OFF|ON",
"LevelOffHidden": "true",
"SelectorStyle": "1"
}
if self.fanStateUnit not in Devices:
Domoticz.Device(Name='Fan state',
Unit=self.fanStateUnit,
TypeName="Selector Switch",
Image=7,
Options=Options).Create()
if self.nightModeUnit not in Devices:
Domoticz.Device(Name='Night mode',
Unit=self.nightModeUnit,
Type=244,
Subtype=62,
Switchtype=0,
Image=9).Create()
Options = {
"LevelActions": "|||||||||||",
"LevelNames": "|1|2|3|4|5|6|7|8|9|10|Auto",
"LevelOffHidden": "false",
"SelectorStyle": "1"
}
if self.fanSpeedUnit not in Devices:
Domoticz.Device(Name='Fan speed',
Unit=self.fanSpeedUnit,
TypeName="Selector Switch",
Image=7,
Options=Options).Create()
if self.fanOscillationUnit not in Devices:
Domoticz.Device(Name='Oscilation mode',
Unit=self.fanOscillationUnit,
Type=244,
Subtype=62,
Image=7,
Switchtype=0).Create()
if self.standbyMonitoringUnit not in Devices:
Domoticz.Device(Name='Standby monitor',
Unit=self.standbyMonitoringUnit,
Type=244,
Subtype=62,
Image=7,
Switchtype=0).Create()
if self.filterLifeUnit not in Devices:
Domoticz.Device(Name='Remaining filter life',
Unit=self.filterLifeUnit,
TypeName="Custom").Create()
if self.tempHumUnit not in Devices:
Domoticz.Device(Name='Temperature and Humidity',
Unit=self.tempHumUnit,
TypeName="Temp+Hum").Create()
if self.volatileUnit not in Devices:
Domoticz.Device(Name='Volatile organic',
Unit=self.volatileUnit,
TypeName="Air Quality").Create()
if self.sleepTimeUnit not in Devices:
Domoticz.Device(Name='Sleep timer',
Unit=self.sleepTimeUnit,
TypeName="Custom").Create()
if self.particlesUnit not in Devices:
Domoticz.Device(Name='Dust',
Unit=self.particlesUnit,
TypeName="Air Quality").Create()
if self.qualityTargetUnit not in Devices:
Options = {
"LevelActions": "||",
"LevelNames":
"|Normal|Sensitive (Medium)|Very Sensitive (High)",
"LevelOffHidden": "true",
"SelectorStyle": "1"
}
Domoticz.Device(Name='Air quality setpoint',
Unit=self.qualityTargetUnit,
TypeName="Selector Switch",
Image=7,
Options=Options).Create()
if self.particles2_5Unit not in Devices:
Domoticz.Device(Name='Dust (PM 2,5)',
Unit=self.particles2_5Unit,
TypeName="Air Quality").Create()
if self.particles10Unit not in Devices:
Domoticz.Device(Name='Dust (PM 10)',
Unit=self.particles10Unit,
TypeName="Air Quality").Create()
Options = {
"LevelActions": "|||",
"LevelNames": "|OFF|ON",
"LevelOffHidden": "true",
"SelectorStyle": "1"
}
if self.fanModeAutoUnit not in Devices:
Domoticz.Device(Name='Fan mode auto',
Unit=self.fanModeAutoUnit,
TypeName="Selector Switch",
Image=7,
Options=Options).Create()
Options = {
"LevelActions": "|||",
"LevelNames": "|OFF|ON",
"LevelOffHidden": "true",
"SelectorStyle": "1"
}
if self.fanFocusUnit not in Devices:
Domoticz.Device(Name='Fan focus mode',
Unit=self.fanFocusUnit,
Type=244,
Subtype=62,
Image=7,
Switchtype=0).Create()
if self.nitrogenDioxideDensityUnit not in Devices:
Domoticz.Device(Name='Nitrogen Dioxide Density (NOx)',
Unit=self.nitrogenDioxideDensityUnit,
TypeName="Air Quality").Create()
#read out parameters for local connection
self.ip_address = Parameters["Address"].strip()
self.port_number = Parameters["Port"].strip()
self.password = self._hashed_password(Parameters['Password'])
mqtt_client_id = ""
self.runCounter = int(Parameters['Mode2'])
#create a Dyson account
Domoticz.Debug("=== start making connection to Dyson account ===")
dysonAccount = DysonAccount(Parameters['Mode5'], Parameters['Mode3'],
"NL")
dysonAccount.login()
#deviceList = ()
deviceList = []
deviceList = dysonAccount.devices()
if deviceList == None or len(deviceList) < 1:
Domoticz.Log("No devices found in Dyson cloud account")
else:
Domoticz.Debug("Number of devices from cloud: '" +
str(len(deviceList)) + "'")
if deviceList != None and len(deviceList) > 0:
if len(Parameters['Mode6']) > 0:
if Parameters['Mode6'] in deviceList:
self.myDevice = deviceList[Parameters['Mode6']]
else:
Domoticz.Error(
"The configured device name '" + Parameters['Mode6'] +
"' was not found in the cloud account. Available options: "
+ str(list(deviceList)))
return
elif len(deviceList) == 1:
self.myDevice = deviceList[list(deviceList)[0]]
Domoticz.Log(
"1 device found in cloud, none configured, assuming we need this one: '"
+ self.myDevice.name + "'")
else:
Domoticz.Error(
"More than 1 device found in cloud account but no device name given to select"
)
return
Domoticz.Debug("local device pwd: '" + self.password + "'")
Domoticz.Debug("cloud device pwd: '" +
self.myDevice.password + "'")
Parameters[
'Username'] = self.myDevice.serial #take username from account
Parameters[
'Password'] = self.myDevice.password #override the default password with the one returned from the cloud
elif len(Parameters['Username']) > 0:
Domoticz.Log(
"No cloud devices found, the local credentials will be used")
#create a Dyson device object using plugin parameters
Domoticz.Debug("local device pwd: '" + self.password + "'")
Domoticz.Debug("local device usn: '" +
Parameters['Username'] + "'")
Parameters['Password'] = self.password
self.myDevice = DysonPureLinkDevice(Parameters['Password'],
Parameters['Username'],
Parameters['Mode1'])
else:
Domoticz.Error("No usable credentials found")
Domoticz.Log("Device instance created: " + str(self.myDevice))
self.base_topic = self.myDevice.device_base_topic
Domoticz.Debug("base topic defined: '" + self.base_topic + "'")
#create the connection
if self.myDevice != None:
self.mqttClient = MqttClient(self.ip_address, self.port_number,
mqtt_client_id, self.onMQTTConnected,
self.onMQTTDisconnected,
self.onMQTTPublish,
self.onMQTTSubscribed)
def onStop(self):
Domoticz.Debug("onStop called")
def onCommand(self, Unit, Command, Level, Hue):
Domoticz.Debug("DysonPureLink plugin: onCommand called for Unit " +
str(Unit) + ": Parameter '" + str(Command) +
"', Level: " + str(Level))
topic = ''
payload = ''
if Unit == self.qualityTargetUnit and Level <= 100:
topic, payload = self.myDevice.set_quality_target(Level)
if Unit == self.fanSpeedUnit and Level <= 100:
arg = "0000" + str(Level // 10)
topic, payload = self.myDevice.set_fan_speed(
arg[-4:]) #use last 4 characters as speed level or AUTO
if Unit == self.fanModeUnit or (Unit == self.fanSpeedUnit
and Level > 100):
if Level == 10: arg = "OFF"
if Level == 20: arg = "FAN"
if Level >= 30: arg = "AUTO"
topic, payload = self.myDevice.set_fan_mode(arg)
if Unit == self.fanStateUnit:
if Level == 10: arg = "OFF"
if Level == 20: arg = "ON"
topic, payload = self.myDevice.set_fan_state(arg)
if Unit == self.fanOscillationUnit:
topic, payload = self.myDevice.set_oscilation(str(Command).upper())
if Unit == self.fanFocusUnit:
topic, payload = self.myDevice.set_focus(str(Command).upper())
if Unit == self.fanModeAutoUnit:
topic, payload = self.myDevice.set_fan_mode_auto(
str(Command).upper())
if Unit == self.standbyMonitoringUnit:
topic, payload = self.myDevice.set_standby_monitoring(
str(Command).upper())
if Unit == self.nightModeUnit:
topic, payload = self.myDevice.set_night_mode(str(Command).upper())
self.mqttClient.Publish(topic, payload)
def onConnect(self, Connection, Status, Description):
Domoticz.Debug("onConnect called: Connection '" + str(Connection) +
"', Status: '" + str(Status) + "', Description: '" +
Description + "'")
self.mqttClient.onConnect(Connection, Status, Description)
def onDisconnect(self, Connection):
self.mqttClient.onDisconnect(Connection)
def onMessage(self, Connection, Data):
self.mqttClient.onMessage(Connection, Data)
def onNotification(self, Name, Subject, Text, Status, Priority, Sound,
ImageFile):
Domoticz.Log("DysonPureLink plugin: onNotification: " + Name + "," +
Subject + "," + Text + "," + Status + "," +
str(Priority) + "," + Sound + "," + ImageFile)
def onHeartbeat(self):
if self.myDevice != None:
self.mqttClient.onHeartbeat()
self.runCounter = self.runCounter - 1
if self.runCounter <= 0:
Domoticz.Debug("DysonPureLink plugin: Poll unit")
self.runCounter = int(Parameters['Mode2'])
topic, payload = self.myDevice.request_state()
self.mqttClient.Publish(
topic, payload) #ask for update of current status
else:
Domoticz.Debug("Polling unit in " + str(self.runCounter) +
" heartbeats.")
def onDeviceRemoved(self, unit):
Domoticz.Log(
"DysonPureLink plugin: onDeviceRemoved called for unit '" +
str(unit) + "'")
def updateDevices(self):
"""Update the defined devices from incoming mesage info"""
#update the devices
UpdateDevice(self.fanOscillationUnit,
self.state_data.oscillation.state,
str(self.state_data.oscillation))
UpdateDevice(self.nightModeUnit, self.state_data.night_mode.state,
str(self.state_data.night_mode))
# Fan speed
f_rate = self.state_data.fan_speed
if (f_rate == "AUTO"):
sValueNew = "110" # Auto
else:
sValueNew = str(int(f_rate) * 10)
UpdateDevice(self.fanSpeedUnit, 1, sValueNew)
UpdateDevice(self.fanModeUnit, self.state_data.fan_mode.state,
str((self.state_data.fan_mode.state + 1) * 10))
UpdateDevice(self.fanStateUnit, self.state_data.fan_state.state,
str((self.state_data.fan_state.state + 1) * 10))
UpdateDevice(self.filterLifeUnit, self.state_data.filter_life,
str(self.state_data.filter_life))
UpdateDevice(self.qualityTargetUnit,
self.state_data.quality_target.state,
str((self.state_data.quality_target.state + 1) * 10))
UpdateDevice(self.standbyMonitoringUnit,
self.state_data.standby_monitoring.state,
str((self.state_data.standby_monitoring.state + 1) * 10))
if self.state_data.fan_mode_auto is not None:
UpdateDevice(self.fanModeAutoUnit,
self.state_data.fan_mode_auto.state,
str((self.state_data.fan_mode_auto.state + 1) * 10))
if self.state_data.focus is not None:
UpdateDevice(self.fanFocusUnit, self.state_data.focus.state,
str(self.state_data.focus))
def updateSensors(self):
"""Update the defined devices from incoming mesage info"""
#update the devices
if self.sensor_data.temperature is not None:
tempNum = int(self.sensor_data.temperature)
humNum = int(self.sensor_data.humidity)
UpdateDevice(
self.tempHumUnit, 1,
str(self.sensor_data.temperature)[:4] + ';' +
str(self.sensor_data.humidity) + ";1")
UpdateDevice(self.volatileUnit, self.sensor_data.volatile_compounds,
str(self.sensor_data.volatile_compounds))
if self.sensor_data.particles is not None:
UpdateDevice(self.particlesUnit, self.sensor_data.particles,
str(self.sensor_data.particles))
if self.sensor_data.particles2_5 is not None:
UpdateDevice(self.particles2_5Unit, self.sensor_data.particles2_5,
str(self.sensor_data.particles2_5))
if self.sensor_data.particles10 is not None:
UpdateDevice(self.particles10Unit, self.sensor_data.particles10,
str(self.sensor_data.particles10))
if self.sensor_data.nitrogenDioxideDensity is not None:
UpdateDevice(self.nitrogenDioxideDensityUnit,
self.sensor_data.nitrogenDioxideDensity,
str(self.sensor_data.nitrogenDioxideDensity))
UpdateDevice(self.sleepTimeUnit, self.sensor_data.sleep_timer,
str(self.sensor_data.sleep_timer))
Domoticz.Debug("update SensorData: " + str(self.sensor_data))
Domoticz.Debug("update StateData: " + str(self.state_data))
def onMQTTConnected(self):
"""connection to device established"""
Domoticz.Debug("onMQTTConnected called")
Domoticz.Log("MQTT connection established")
self.mqttClient.Subscribe([self.base_topic + '/#'
]) #subscribe to all topics on the machine
topic, payload = self.myDevice.request_state()
self.mqttClient.Publish(topic,
payload) #ask for update of current status
def onMQTTDisconnected(self):
Domoticz.Debug("onMQTTDisconnected")
def onMQTTSubscribed(self):
Domoticz.Debug("onMQTTSubscribed")
def onMQTTPublish(self, topic, message):
Domoticz.Debug("MQTT Publish: MQTT message incoming: " + topic + " " +
str(message))
if (topic == self.base_topic + '/status/current'):
#update of the machine's status
if StateData.is_state_data(message):
Domoticz.Debug("machine state or state change recieved")
self.state_data = StateData(message)
self.updateDevices()
if SensorsData.is_sensors_data(message):
Domoticz.Debug("sensor state recieved")
self.sensor_data = SensorsData(message)
self.updateSensors()
if (topic == self.base_topic + '/status/connection'):
#connection status received
Domoticz.Debug("connection state recieved")
if (topic == self.base_topic + '/status/software'):
#connection status received
Domoticz.Debug("software state recieved")
if (topic == self.base_topic + '/status/summary'):
#connection status received
Domoticz.Debug("summary state recieved")
def _hashed_password(self, pwd):
"""Hash password (found in manual) to a base64 encoded of its sha512 value"""
hash = hashlib.sha512()
hash.update(pwd.encode('utf-8'))
return base64.b64encode(hash.digest()).decode('utf-8')
class BasePlugin:
mqttClient = None
def onStart(self):
self.debugging = Parameters["Mode6"]
if self.debugging == "Verbose":
Domoticz.Debugging(2 + 4 + 8 + 16 + 64)
if self.debugging == "Debug":
Domoticz.Debugging(2)
self.base_topic = "shellies" # hardwired
self.mqttserveraddress = Parameters["Address"].strip()
self.mqttserverport = Parameters["Port"].strip()
self.mqttClient = MqttClient(self.mqttserveraddress,
self.mqttserverport, self.onMQTTConnected,
self.onMQTTDisconnected,
self.onMQTTPublish, self.onMQTTSubscribed)
def checkDevices(self):
Domoticz.Debug("checkDevices called")
def onStop(self):
Domoticz.Debug("onStop called")
def onCommand(self, Unit, Command, Level,
Color): # react to commands arrived from Domoticz
Domoticz.Debug("Command: " + Command + " (" + str(Level) + ") Color:" +
Color)
device = Devices[Unit]
device_id = device.DeviceID.split('-')
relnum = -1
try:
relnum = int(device_id[2].strip())
except:
relnum = -1
if relnum in range(
0, 4) and len(device_id) == 3: # check if is it a normal relay
mqttpath = self.base_topic + "/" + device_id[0] + "-" + device_id[
1] + "/relay/" + device_id[2] + "/command"
cmd = Command.strip().lower()
Domoticz.Debug(mqttpath + " " + cmd)
if cmd in ["on", "off"]: # commands are simply on or off
self.mqttClient.Publish(mqttpath, cmd)
if cmd == "off":
device.Update(
Level, Command) # force device update if it is offline
# otherwise check if it is a roller shutter
elif relnum in range(
0, 4) and len(device_id) == 4 and device_id[len(device_id) -
1] == "roller":
cmd = Command.strip().lower()
scmd = "" # Translate Domoticz command to Shelly command
if cmd == "stop":
scmd = "stop"
elif cmd == "on":
scmd = "open"
elif cmd == "off":
scmd = "close"
if scmd != "":
mqttpath = self.base_topic + "/" + device_id[
0] + "-" + device_id[1] + "/roller/" + device_id[
2] + "/command"
self.mqttClient.Publish(mqttpath, scmd)
# experimental support for v1.4 Percentage poisitioning
elif relnum in range(
0, 4) and len(device_id) == 4 and device_id[len(device_id) -
1] == "pos":
cmnd = str(Command).strip().lower()
pos = str(Level).strip().lower()
if ((cmnd == "set level")
or (cmnd == "off" and pos != "50"
and pos != "100")): # percentage requested
mqttpath = self.base_topic + "/" + device_id[
0] + "-" + device_id[1] + "/roller/" + device_id[
2] + "/command/pos"
Domoticz.Debug(mqttpath + " " + str(Command) + " " +
str(Level))
self.mqttClient.Publish(mqttpath, pos)
else: # command arrived
scmd = "" # Translate Domoticz command to Shelly command
if cmnd == "on":
scmd = "open"
elif cmnd == "off":
scmd = "close"
if scmd != "":
mqttpath = self.base_topic + "/" + device_id[
0] + "-" + device_id[1] + "/roller/" + device_id[
2] + "/command"
self.mqttClient.Publish(mqttpath, scmd)
def onConnect(self, Connection, Status, Description):
self.mqttClient.onConnect(Connection, Status, Description)
def onDisconnect(self, Connection):
self.mqttClient.onDisconnect(Connection)
def onMessage(self, Connection, Data):
self.mqttClient.onMessage(Connection, Data)
def onHeartbeat(self):
Domoticz.Debug("Heartbeating...")
# Reconnect if connection has dropped
if self.mqttClient.mqttConn is None or (
not self.mqttClient.mqttConn.Connecting()
and not self.mqttClient.mqttConn.Connected()
or not self.mqttClient.isConnected):
Domoticz.Debug("Reconnecting")
self.mqttClient.Open()
else:
self.mqttClient.Ping()
def onMQTTConnected(self):
self.mqttClient.Subscribe([self.base_topic + '/#'])
def onMQTTDisconnected(self):
Domoticz.Debug("onMQTTDisconnected")
def onMQTTSubscribed(self):
Domoticz.Debug("onMQTTSubscribed")
def onMQTTPublish(self, topic, message): # process incoming MQTT statuses
if "/announce" in topic: # announce did not contain any information for us
return False
try:
topic = str(topic)
message = str(message)
except:
Domoticz.Debug("MQTT message is not a valid string!"
) #if message is not a real string, drop it
return False
Domoticz.Debug("MQTT message: " + topic + " " + str(message))
mqttpath = topic.split('/')
if (mqttpath[0] == self.base_topic):
# RELAY type, not command->process
if (len(mqttpath) > 3) and (mqttpath[2]
== "relay") and ("/command"
not in topic):
unitname = mqttpath[1] + "-" + mqttpath[3]
unitname = unitname.strip()
devtype = 1
try:
funcid = int(mqttpath[3].strip())
devtype = 0
except:
devtype = 1
if len(mqttpath) == 5 and devtype == 0:
devtype = 2
subval = ""
if devtype == 1:
subval = mqttpath[3].strip()
elif devtype == 2:
subval = mqttpath[4].strip()
if subval == "power" or subval == "energy":
unitname = mqttpath[1] + "-energy"
iUnit = -1
for Device in Devices:
try:
if (Devices[Device].DeviceID.strip() == unitname):
iUnit = Device
break
except:
pass
if iUnit < 0: # if device does not exists in Domoticz, than create it
iUnit = 0
for x in range(1, 256):
if x not in Devices:
iUnit = x
break
if iUnit == 0:
iUnit = len(Devices) + 1
if devtype == 0:
Domoticz.Device(Name=unitname,
Unit=iUnit,
TypeName="Switch",
Used=1,
DeviceID=unitname).Create()
else:
if subval == "energy" or subval == "power":
Domoticz.Device(Name=unitname,
Unit=iUnit,
Type=243,
Subtype=29,
Used=1,
DeviceID=unitname).Create()
if devtype == 0:
scmd = str(message).strip().lower()
if (str(Devices[iUnit].sValue).lower() != scmd):
if (scmd == "on"): # set device status if needed
Devices[iUnit].Update(1, "On")
else:
Devices[iUnit].Update(0, "Off")
else:
curval = Devices[iUnit].sValue
try:
prevdata = curval.split(";")
except:
prevdata = []
if len(prevdata) < 2:
prevdata.append(0)
prevdata.append(0)
try:
mval = float(str(message).strip())
except:
mval = str(message).strip()
sval = ""
if subval == "power":
sval = str(mval) + ";" + str(prevdata[1])
elif subval == "energy":
try:
mval2 = (mval / 100) # 10*Wh?
except:
mval2 = str(mval)
sval = str(prevdata[0]) + ";" + str(mval2)
Devices[iUnit].Update(0, sval)
return True
# ROLLER type, not command->process
elif (len(mqttpath) > 3) and (mqttpath[2]
== "roller") and ("/command"
not in topic):
if mqttpath[len(mqttpath) - 1] == "pos":
unitname = mqttpath[1] + "-" + mqttpath[3] + "-pos"
else:
unitname = mqttpath[1] + "-" + mqttpath[3] + "-roller"
unitname = unitname.strip()
iUnit = -1
for Device in Devices:
try:
if (Devices[Device].DeviceID.strip() == unitname):
iUnit = Device
break
except:
pass
if iUnit < 0: # if device does not exists in Domoticz, than create it
iUnit = 0
for x in range(1, 256):
if x not in Devices:
iUnit = x
break
if iUnit == 0:
iUnit = len(Devices) + 1
if "-pos" in unitname:
Domoticz.Device(Name=unitname,
Unit=iUnit,
Type=244,
Subtype=62,
Switchtype=13,
Used=1,
DeviceID=unitname).Create(
) # create Blinds Percentage
else:
Domoticz.Device(Name=unitname,
Unit=iUnit,
Type=244,
Subtype=62,
Switchtype=15,
Used=1,
DeviceID=unitname).Create(
) # create Venetian Blinds EU type
if "-pos" in unitname:
try:
pval = str(message).strip()
nval = 0
if int(pval) > 0 and int(pval) < 100:
nval = 2
if int(pval) > 99:
nval = 1
Devices[iUnit].Update(nval, pval)
except:
Domoticz.Debug("MQTT message error " + str(topic) +
":" + str(message))
else:
bcmd = str(message).strip().lower()
if bcmd == "stop" and str(
Devices[iUnit].sValue).lower() != "stop":
Devices[iUnit].Update(17, "Stop") # stop
return True
elif bcmd == "open" and str(
Devices[iUnit].sValue).lower() != "off":
Devices[iUnit].Update(0, "Off") # open
return True
elif bcmd == "close" and str(
Devices[iUnit].sValue).lower() != "on":
Devices[iUnit].Update(1, "On") # close
return True
# INPUT type, not command->process
elif (len(mqttpath) > 3) and (mqttpath[2] == "input") and (
mqttpath[len(mqttpath) - 1] != "command"):
unitname = mqttpath[1] + "-" + mqttpath[3] + "-input"
unitname = unitname.strip()
iUnit = -1
for Device in Devices:
try:
if (Devices[Device].DeviceID.strip() == unitname):
iUnit = Device
break
except:
pass
if iUnit < 0: # if device does not exists in Domoticz, than create it
iUnit = 0
for x in range(1, 256):
if x not in Devices:
iUnit = x
break
if iUnit == 0:
iUnit = len(Devices) + 1
Domoticz.Device(Name=unitname,
Unit=iUnit,
TypeName="Switch",
Used=1,
DeviceID=unitname).Create()
if str(message).lower == "on" or str(message) == "1":
scmd = "on"
else:
scmd = "off"
if (str(Devices[iUnit].sValue).lower() != scmd):
if (scmd == "on"): # set device status if needed
Devices[iUnit].Update(1, "On")
else:
Devices[iUnit].Update(0, "Off")
# SENSOR type, not command->process
elif (len(mqttpath) > 3) and (mqttpath[2] == "sensor") and (
mqttpath[3] in ['temperature', 'humidity', 'battery'
]) and (("shellysense" in mqttpath[1]) or
("shellyht" in mqttpath[1])):
unitname = mqttpath[1] + "-sensor"
unitname = unitname.strip()
iUnit = -1
for Device in Devices:
try:
if (Devices[Device].DeviceID.strip() == unitname):
iUnit = Device
break
except:
pass
if iUnit < 0: # if device does not exists in Domoticz, than create it
iUnit = 0
for x in range(1, 256):
if x not in Devices:
iUnit = x
break
if iUnit == 0:
iUnit = len(Devices) + 1
Domoticz.Device(
Name=unitname,
Unit=iUnit,
TypeName="Temp+Hum",
Used=1,
DeviceID=unitname).Create() # create Temp+Hum Type=82
stype = mqttpath[3].strip().lower()
curval = Devices[iUnit].sValue
try:
mval = float(message)
except:
mval = str(message).strip()
if stype == "battery":
Devices[iUnit].Update(0, curval, BatteryLevel=int(mval))
elif stype == "temperature":
try:
env = curval.split(";")
except:
env = [0, 0]
if len(env) < 3:
env.append(0)
env.append(0)
env.append(0)
sval = str(mval) + ";" + str(env[1]) + ";" + str(env[2])
Devices[iUnit].Update(0, sval)
elif stype == "humidity":
hstat = 0
try:
env = curval.split(";")
except:
env = [0, 0]
if len(env) < 1:
env.append(0)
if int(mval) >= 50 and int(mval) <= 70:
hstat = 1
elif int(mval) < 40:
hstat = 2
elif int(mval) > 70:
hstat = 3
sval = str(env[0]) + ";" + str(mval) + ";" + str(hstat)
Devices[iUnit].Update(0, sval)
class BasePlugin:
mqttClient = None
domoticzDevicesByName = None
domoticzDevicesById = None
linkedDevices = None
def onStart(self):
self.debugging = Parameters["Mode6"]
if self.debugging == "Verbose":
Domoticz.Debugging(2 + 4 + 8 + 16 + 64)
if self.debugging == "Debug":
Domoticz.Debugging(2)
Domoticz.Debug("onStart called")
self.base_topic = Parameters["Mode1"].strip()
self.domoticz_port = int(Parameters["Port"].strip())
self.delete_removed_devices = Parameters["Mode5"].strip()
if Parameters["Address"].find('mqtt.gbridge.io') >= 0:
self.domoticz_mqtt_used = False
else:
self.domoticz_mqtt_used = True
self.mqttClient = MqttClient(Parameters["Address"].strip().split(":")[0],
Parameters["Address"].strip().split(":")[1],
self.onMQTTConnected,
self.onMQTTDisconnected,
self.onMQTTPublish,
self.onMQTTSubscribed)
self.gBridgeClient = gBridgeClient(Parameters["Mode2"].strip(),
Parameters["Mode3"].strip(),
Parameters["Mode4"].strip())
self.domoticz_client = DomoticzClient(self.domoticz_port)
self.syncDevices()
Domoticz.Debug("Done")
def syncDevices(self):
Domoticz.Debug('Starting sync')
bridge_devices = self.gBridgeClient.fetchDevicesFromBridge()
domoticz_devices = self.domoticz_client.fetchDevicesFromDomoticz()
self.linkedDevices = self.domoticz_client.getLinkedDevices(domoticz_devices)
Domoticz.Debug('Linked devices: ' + str(self.linkedDevices))
self.domoticzDevicesByName = self.domoticz_client.getDevicesByName(domoticz_devices)
self.domoticzDevicesById = {x['idx']: x for x in list(self.domoticzDevicesByName.values())}
Domoticz.Debug('Domoticz devices available for gBridge: ' + str(self.domoticzDevicesByName.keys()))
self.gBridgeClient.syncDevices(self.domoticzDevicesByName, bridge_devices,
self.delete_removed_devices == 'True')
def onStop(self):
Domoticz.Debug("onStop called")
def onCommand(self, Unit, Command, Level, Color):
Domoticz.Debug("onCommand: " + Command + ", level (" + str(Level) + ") Color:" + Color)
def onConnect(self, Connection, Status, Description):
Domoticz.Debug("onConnect called")
self.mqttClient.onConnect(Connection, Status, Description)
def onDisconnect(self, Connection):
self.mqttClient.onDisconnect(Connection)
def onMessage(self, Connection, Data):
Domoticz.Debug('Incoming message!' + str(Data))
self.mqttClient.onMessage(Connection, Data)
def onHeartbeat(self):
Domoticz.Debug("Heartbeating...")
# Reconnect if connection has dropped
if self.mqttClient.mqttConn is None or (
not self.mqttClient.mqttConn.Connecting() and not self.mqttClient.mqttConn.Connected() or not self.mqttClient.isConnected):
Domoticz.Debug("Reconnecting")
self.mqttClient.Open()
else:
self.mqttClient.Ping()
def onMQTTConnected(self):
self.mqttClient.Subscribe([self.base_topic + '/#'])
if self.domoticz_mqtt_used:
self.mqttClient.Subscribe(['domoticz/out'])
def onMQTTDisconnected(self):
Domoticz.Debug("onMQTTDisconnected")
def onMQTTSubscribed(self):
Domoticz.Debug("onMQTTSubscribed")
def onMQTTPublish(self, topic, message):
Domoticz.Debug("MQTT message: " + topic + " " + str(message))
if str(topic) == 'domoticz/out':
if message.get('idx') is not None:
domoticz_id = str(message['idx'])
if message.get('Type') is not None and (message['Type'] == 'Scene' or message['Type'] == 'Group'):
domoticz_id = 'group_' + domoticz_id
else:
return
device = None
if domoticz_id in self.domoticzDevicesById:
device = self.domoticzDevicesById[domoticz_id]
elif domoticz_id in self.linkedDevices and self.linkedDevices[domoticz_id] in self.domoticzDevicesById:
# Get the device to which this device message is linked to, for example, device id 13 -> update device 12
device = self.domoticzDevicesById[self.linkedDevices[domoticz_id]]
if device is not None:
adapter = getAdapter(device)
if adapter is not None:
adapter.publishStateFromDomoticzTopic(self.mqttClient, device, self.base_topic, message)
else:
Domoticz.Error('No adapter registered to publish state for device: %s' % str(device))
else:
if message == 'SYNC':
self.syncDevices()
elif topic.endswith('/set'):
Domoticz.Debug('Published new state for device, topic: %s, state: %s' % (topic, message))
else:
match = re.search(self.base_topic + '/(.*)/(.*)', topic)
if match:
device_id = match.group(1)
# Backwards compatibility, previously the device name was used as topic name
if device_id in self.domoticzDevicesByName:
device = self.domoticzDevicesByName[device_id]
elif device_id in self.domoticzDevicesById:
device = self.domoticzDevicesById[device_id]
else:
Domoticz.Log('Received message for device which is not in Domoticz: %s, skipping' % device_id)
return
action = match.group(2)
adapter = getAdapter(device)
if adapter is not None:
adapter.handleMqttMessage(device, str(message), action, self.domoticz_port)
if not self.domoticz_mqtt_used:
adapter.publishState(self.mqttClient, device, self.base_topic, message) # answer directly
else:
Domoticz.Error('No adapter registered for action: %s for device: %s' % (action, str(device)))