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)
DumpConfigToLog()
Domoticz.Log("Chirpstack2Domoticz Plugin started")
#App ID Base TOPIC
if (Parameters["Mode1"].strip() != ""):
self.base_topic = "application/" + Parameters["Mode1"].strip()
else:
Domoticz.Log(
"Warning : No Application ID submitted. It will subscribe to all application topics"
)
self.base_topic = "application"
self.subscribed_for_devices = False
self.create_new_devices = Parameters["Mode2"].strip()
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.api = API(Devices, self.publishToMqtt)
def onStart(self):
if errmsg == "":
try:
Domoticz.Heartbeat(10)
self.debugging = Parameters["Mode6"]
if self.debugging == "Verbose":
Domoticz.Debugging(2+4+8+16+64)
if self.debugging == "Debug":
Domoticz.Debugging(2)
global pluginDebug
pluginDebug = False
setTasmotaDebug(True)
setMqttDebug(False)
Debug("Plugin::onStart: Parameters: {}".format(repr(Parameters)))
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)
self.mqttClient.debug(False)
self.tasmotaHandler = Handler(Parameters["Mode4"].strip().split('|'), Parameters["Mode1"].strip(
), Parameters["Mode2"].strip(), Parameters["Mode3"].strip(), self.mqttClient, Devices)
self.tasmotaHandler.debug(True)
except Exception as e:
Domoticz.Error("Plugin::onStart: {}".format(str(e)))
self.mqttClient = None
else:
Domoticz.Error(
"Plugin::onStart: Domoticz Python env error {}".format(errmsg))
self.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.devices_manager = DevicesManager()
self.devices_manager.set_devices(Devices)
device_topic = Parameters["Mode1"].strip()
if (Parameters["Mode2"] == "Dimmer"):
self.controller = Dimmer(self.devices_manager, device_topic)
elif (Parameters["Mode2"] == "PwmDimmer"):
self.controller = PwmDimmer(self.devices_manager, device_topic)
elif (Parameters["Mode2"] == "RGB"):
self.controller = ColorDimmer(self.devices_manager, device_topic, 3)
elif (Parameters["Mode2"] == "RGBW"):
self.controller = ColorDimmer(self.devices_manager, device_topic, 4)
elif (Parameters["Mode2"] == "RGBWW"):
self.controller = ColorDimmer(self.devices_manager, device_topic, 5)
self.controller.checkDevices()
self.topics = list(["stat/" + device_topic + "/RESULT", "tele/" + device_topic + "/STATE"])
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)
def onStart(self):
global errmsg
self.devnames = []
self.devtimes = []
if errmsg == "":
try:
Domoticz.Heartbeat(10)
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 = Parameters["Mode1"]
self.learnmode = Parameters["Mode2"]
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)
except Exception as e:
Domoticz.Error("MQTT client start error: " + str(e))
self.mqttClient = None
else:
Domoticz.Error(
"Your Domoticz Python environment is not functional! " +
errmsg)
self.mqttClient = None
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 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")
class Server(object):
app = Flask(__name__)
MQTTC = MqttClient()
@app.route("/", methods=['GET', 'POST'])
def Welcome():
return "Welcome to my page :)"
"""webhook api"""
@app.route("/webhook", methods=['GET'])
def verify():
return request.args.get('hub.challenge')
@app.route("/webhook", methods=['POST'])
def fb_feeds_webhook():
"""webhook api"""
print('Handling webhook request!!')
content = request.get_json()
if content['entry'][0]['changes'][0]['value']['item'] == 'like':
msg = {
"time": int(content['entry'][0]['time']),
"topic": "LIKE",
"user_id":
content['entry'][0]['changes'][0]['value']['user_id']
}
Server.MQTTC.publish('Facebook', msg)
print('Handled webhook request' + str(content))
return ''
def onStart(self):
if Parameters["Mode6"] == "Debug":
Domoticz.Debugging(1)
DumpConfigToLog()
self.devices = {}
Parameters["Username"] = "******"
Parameters["Port"] = "8884"
Parameters["Protocol"] = "MQTTS"
mqtt_server_address = Parameters["Address"].strip()
mqtt_server_port = Parameters["Port"].strip()
self.mqttClient = MqttClient(mqtt_server_address, mqtt_server_port,
"NHCDomoticz", self.onMQTTConnected,
self.onMQTTDisconnected,
self.onMQTTPublish, self.onMQTTSubscribed)
class Server(object):
app = Flask(__name__)
MQTTC = MqttClient()
@app.route("/")
def getRequest():
return "Hello World!"
"""webhook api"""
@app.route("/webhook", methods=['GET'])
def verify():
return request.args.get('hub.challenge')
@app.route("/webhook", methods=['POST'])
def fb_feeds_webhook():
"""webhook api"""
logging.debug('Handling webhook request!!')
content = request.get_json()
if content['entry'][0]['changes'][0]['value']['item'] == 'like':
Server.MQTTC.publish(
Config.MQTT_FB_WEBHOOK_TOPIC_NAME, Msg(
int(content['entry'][0]['time']),'LIKE',
content['entry'][0]['changes'][0]['value']['user_id']))
logging.info('Handled webhook request ' + str(content))
return ''
if __name__ == '__main__':
app.debug = True
app.run(host = '0.0.0.0', port = int(os.environ.get("PORT", 5000)))
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 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 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.install()
self.base_topic = Parameters["Mode1"].strip()
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.api = API(Devices, self.onApiCommand)
self.devices_manager = DevicesManager()
self.groups_manager = GroupsManager()
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.devices = {}
self.base_topic = Parameters["Mode1"].strip()
mqttserver_address = Parameters["Address"].strip()
mqttserver_port = Parameters["Port"].strip()
mqtt_client_id = Parameters["Mode3"].strip()
self.mqttClient = MqttClient(mqttserver_address, mqttserver_port,
mqtt_client_id, self.onMQTTConnected,
self.onMQTTDisconnected,
self.onMQTTPublish, self.onMQTTSubscribed)
Domoticz.Debug("onStart called")
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 = Thermostat()
self.controller.checkDevices()
self.topics = list([
"ems-esp/thermostat_data1", "ems-esp/boiler_data", "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 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.install()
self.base_topic = "zigbee2mqtt"
self.subscribed_for_devices = False
mqtt_server_address = "127.0.0.1"
mqtt_server_port = "1883"
mqtt_client_id = ""
self.mqttClient = MqttClient(mqtt_server_address, mqtt_server_port,
mqtt_client_id, self.onMQTTConnected,
self.onMQTTDisconnected,
self.onMQTTPublish, self.onMQTTSubscribed)
self.api = API(Devices, self.onApiCommand)
self.devices_manager = DevicesManager()
self.groups_manager = GroupsManager()
class Server(object):
"""Server class"""
app = Flask(__name__)
MQTTC = MqttClient()
@app.route("/")
def hello(self):
"""default"""
return "Hello World!"
@app.route("/webhook", methods=['GET'])
def verify(self):
"""webhook api"""
return request.args.get('hub.challenge')
@app.route("/webhook", methods=['POST'])
def fb_feeds_webhook(self):
"""webhook api"""
content = request.get_json()
if content['entry'][0]['changes'][0]['value']['item'] == 'like':
Server.MQTTC.publish(
Credentials.MQTT_FB_WEBHOOK_TOPIC_NAME,
Msg(int(content['entry'][0]['time']), 'LIKE',
content['entry'][0]['changes'][0]['value']['user_id']))
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)
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):
permit_join = 'true' if self.pairing_enabled else 'false'
self.mqttClient.publish(self.base_topic + '/bridge/config/permit_join',
permit_join)
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):
self.subscribed_for_devices = False
def onMQTTSubscribed(self):
Domoticz.Debug("onMQTTSubscribed")
def onMQTTPublish(self, topic, message):
Domoticz.Debug("MQTT message: " + topic + " " + str(message))
if (topic == self.base_topic + '/bridge/config/permit_join'
or topic == self.base_topic + '/bridge/config/devices'):
return
if (topic == self.base_topic + '/bridge/config'):
permit_join = 'enabled' if message['permit_join'] else 'disabled'
Domoticz.Debug('Zigbee2mqtt log level is ' + message['log_level'])
Domoticz.Log('Joining new devices is ' + permit_join +
' on the zigbee bridge')
return
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.clear()
self.available_devices.update(Devices, message['message'])
if self.subscribed_for_devices == False:
self.mqttClient.subscribe([self.base_topic + '/+'])
self.subscribed_for_devices = True
if message['type'] == 'device_connected' or message[
'type'] == 'device_removed':
self.mqttClient.publish(
self.base_topic + '/bridge/config/devices', '')
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:
mqttClient = None
def CS_2_DZ_decoder(self, topic, message):
success = 0
Domoticz.Debug("CS_Decoder")
EUI = str(topic.split("device/")[1].split("/")[0])
Domoticz.Debug("EUI : " + EUI)
############
## Devices
payload = json.loads(message)
Domoticz.Debug("Payload:\n" + str(payload))
if not 'loRaSNR' in str(payload):
Domoticz.Log(
"Decoding LoRa message problem. Check ChirpStack application.")
return success
RSSI = payload['rxInfo'][0]['loRaSNR']
RSSI = int(round(mapFromTo(int(RSSI), -20, 0, 0, 10),
0)) #Domoticz : between 0 and 10
Domoticz.Debug("RSSI : " + str(RSSI))
CS_objects = json.loads(payload['objectJSON'])
if (len(CS_objects) == 0):
Domoticz.Log(
"Decoding cayenne message problem. Check ChirpStack application."
)
return success
#Domoticz.Debug(str(CS_objects))#{'temperatureSensor': {'1': 12}, 'humiditySensor': {'1': 80}}
#Reorganize data
data = []
for obj in CS_objects:
if (str(obj) in CS_cayenne_to_DZ):
for channel in CS_objects[str(obj)]:
#Get the value of the sensor
value = str(CS_objects[str(obj)][str(channel)])
#build DATA : [Channel, value, [Corresp.DZ_TypeName, Corresp.DZ_pType,DZ_sType, Corresp.FancyName, Corresp.UNIT_ID] ]
data.append([channel, value, CS_cayenne_to_DZ[str(obj)]])
else:
Domoticz.Log("Unfound/Unproccessable Cayenne Data Type : " +
str(obj))
Domoticz.Debug("DATA structure:" + str(data))
#[['1', '12', ['Temperature', 243, 17, 'temp']], ['2', '14', ['Temperature', 243, 17, 'temp']], ['3', '15', ['Temperature', 243, 17, 'temp']], ['1', '80', ['Humidity', 243, 3, 'hum']]]
# #aggregate several sensor types into one sensor. Decide whi one is nvalue, which one is svalue
# # TODO
data_ag = data
#Devices ID
d_ids = []
d_units = []
for x in Devices:
d_ids.append([
str(x),
str(Devices[x].ID),
str(Devices[x].Name),
str(Devices[x].DeviceID)
])
d_units.append(int(x))
Domoticz.Debug(str(d_ids))
Domoticz.Debug(str(d_units))
#Device
for d in range(0, len(data_ag)):
# Case there is Type_Name assigned
if data_ag[d][2][0] != "":
#Shape the values
device_fancyname = str(data_ag[d][2][3])
device_id = "eui-" + EUI + "-" + str(
data_ag[d]
[0]) + "-" + device_fancyname #eui-a8d4fdf51239f322-1-hum
device_Name = "Unknown " + device_fancyname
device_TypeName = str(data_ag[d][2][0])
Domoticz.Debug("===================")
Domoticz.Debug("device_id: " + str(device_id))
#If not exist, create
if (device_id not in str(d_ids)):
#Find a new unit ID
device_Unit = 0
for u in range(1, 255):
if u not in d_units:
device_Unit = u
d_units.append(u)
break
if device_Unit == 0:
Domoticz.Log(
"ERROR - No more UNIT ID to allocate. Device not created"
)
return 0
Domoticz.Debug("device_Name: " + str(device_Name))
Domoticz.Debug("device_TypeName: " + str(device_TypeName))
if self.create_new_devices == "True":
Domoticz.Log(
"ChirpStack Plugin - Create NEW device with ID=" +
str(device_id) + ", Name=" + str(device_Name) +
", Type=" + str(device_TypeName))
#Create
Domoticz.Device(Name=device_Name,
TypeName=device_TypeName,
Unit=device_Unit,
DeviceID=device_id).Create()
else:
Domoticz.Log(
"ChirpStack Plugin - DISBALED [Create device " +
str(device_id) + "]")
for x in Devices:
#Check if now exists, and update
if (str(Devices[x].DeviceID) == device_id):
device_svalue = str(data_ag[d][1])
#Update
Domoticz.Log("Chirpstack Plugin - Update device (ID=" +
str(Devices[x].ID) + ") value =" +
data_ag[d][1])
Devices[x].Update(nValue=int(device_svalue),
sValue=str(device_svalue),
SignalLevel=RSSI)
Domoticz.Debug("===================")
return success
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)
DumpConfigToLog()
Domoticz.Log("Chirpstack2Domoticz Plugin started")
#App ID Base TOPIC
if (Parameters["Mode1"].strip() != ""):
self.base_topic = "application/" + Parameters["Mode1"].strip()
else:
Domoticz.Log(
"Warning : No Application ID submitted. It will subscribe to all application topics"
)
self.base_topic = "application"
self.subscribed_for_devices = False
self.create_new_devices = Parameters["Mode2"].strip()
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.api = API(Devices, self.publishToMqtt)
def checkDevices(self):
Domoticz.Debug("checkDevices called")
def onStop(self):
Domoticz.Debug("onStop called")
#self.uninstall()
def onCommand(self, Unit, Command, Level, Color):
Domoticz.Debug("onCommand: " + Command + ", level (" + str(Level) +
") Color:" + Color)
message = None
device = Devices[
Unit] #Devices is Domoticz collection of devices for this hardware
device_params = device.DeviceID.split('_')
entity_id = device_params[0]
Domoticz.Debug("OnCommand --> Partie desctivee")
# if (self.devices_manager.get_device_by_id(entity_id) != None):
# message = self.devices_manager.handle_command(Devices, device, Command, Level, Color)
# elif(self.groups_manager.get_group_by_deviceid(device.DeviceID) != None):
# message = self.groups_manager.handle_command(device, Command, Level, Color)
# else:
# Domoticz.Log('Can\'t process command from device "' + device.Name + '"')
# if (message != None):
# self.publishToMqtt(message['topic'], message['payload'])
def publishToMqtt(self, topic, payload):
self.mqttClient.publish(self.base_topic + '/' + topic, payload)
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 onDeviceModified(self, unit):
if (unit == 255):
self.api.handle_request(Devices[unit].sValue)
return
def onMessage(self, Connection, Data):
self.mqttClient.onMessage(Connection, Data)
def onHeartbeat(self):
self.mqttClient.onHeartbeat()
def onMQTTConnected(self):
#if connected subscirbe to topic
self.mqttClient.subscribe([self.base_topic + "/#"])
Domoticz.Log("MQTT subscribed to : " + self.base_topic + "/#")
def onMQTTDisconnected(self):
self.subscribed_for_devices = False
def onMQTTSubscribed(self):
Domoticz.Debug("onMQTTSubscribed")
def onMQTTPublish(self, topic, message):
Domoticz.Debug("On MQTT Publish")
payload = json.dumps(message)
Domoticz.Debug("MQTT message: " + topic + " " + str(payload))
topic = topic.replace(self.base_topic + '/', '')
#self.api.handle_mqtt_message(topic, message)
#Decode the pyaload and message. --> Will automatically add sensors
self.CS_2_DZ_decoder(topic, payload)
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.devices_manager = DevicesManager()
self.devices_manager.set_devices(Devices)
device_topic = Parameters["Mode1"].strip()
if (Parameters["Mode2"] == "Dimmer"):
self.controller = Dimmer(self.devices_manager, device_topic)
elif (Parameters["Mode2"] == "PwmDimmer"):
self.controller = PwmDimmer(self.devices_manager, device_topic)
elif (Parameters["Mode2"] == "RGB"):
self.controller = ColorDimmer(self.devices_manager, device_topic, 3)
elif (Parameters["Mode2"] == "RGBW"):
self.controller = ColorDimmer(self.devices_manager, device_topic, 4)
elif (Parameters["Mode2"] == "RGBWW"):
self.controller = ColorDimmer(self.devices_manager, device_topic, 5)
self.controller.checkDevices()
self.topics = list(["stat/" + device_topic + "/RESULT", "tele/" + device_topic + "/STATE"])
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)
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) + ") Color:" + Color)
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):
self.mqttClient.onHeartbeat()
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, message):
Domoticz.Debug("MQTT message: " + topic + " " + str(message))
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.devices_manager = DevicesManager()
self.groups_manager = GroupsManager()
def checkDevices(self):
Domoticz.Debug("checkDevices called")
def onStop(self):
Domoticz.Debug("onStop called")
def handlePairingMode(self):
permit_join = 'true' if self.pairing_enabled else 'false'
self.mqttClient.publish(self.base_topic + '/bridge/config/permit_join',
permit_join)
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('_')
entity_id = device_params[0]
if (self.devices_manager.get_device_by_id(entity_id) != None):
message = self.devices_manager.handle_command(
Devices, device, Command, Level, Color)
elif (self.groups_manager.get_group_by_deviceid(device.DeviceID) !=
None):
message = self.groups_manager.handle_command(
device, Command, Level, Color)
else:
Domoticz.Log('Can\'t process command from device "' + device.Name +
'"')
if (message != None):
self.mqttClient.publish(self.base_topic + '/' + message['topic'],
message['payload'])
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):
self.subscribed_for_devices = False
def onMQTTSubscribed(self):
Domoticz.Debug("onMQTTSubscribed")
def onMQTTPublish(self, topic, message):
Domoticz.Debug("MQTT message: " + topic + " " + str(message))
if (topic == self.base_topic + '/bridge/config/permit_join'
or topic == self.base_topic + '/bridge/config/devices'):
return
if (topic == self.base_topic + '/bridge/config'):
permit_join = 'enabled' if message['permit_join'] else 'disabled'
Domoticz.Debug('Zigbee2mqtt log level is ' + message['log_level'])
Domoticz.Log('Joining new devices is ' + permit_join +
' on the zigbee bridge')
return
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.mqttClient.publish(
self.base_topic + '/bridge/config/groups', '')
self.handlePairingMode()
return
if (topic == self.base_topic + '/bridge/log'):
if message['type'] == 'devices':
Domoticz.Log('Received available devices list from bridge')
self.devices_manager.clear()
self.devices_manager.update(Devices, message['message'])
if self.subscribed_for_devices == False:
self.mqttClient.subscribe([self.base_topic + '/+'])
self.subscribed_for_devices = True
if message['type'] == 'groups':
Domoticz.Log('Received groups list from bridge')
self.groups_manager.register_groups(Devices,
message['message'])
if message['type'] == 'device_connected' or message[
'type'] == 'device_removed':
self.mqttClient.publish(
self.base_topic + '/bridge/config/devices', '')
return
entity_name = topic.replace(self.base_topic + "/", "")
if (self.devices_manager.get_device_by_name(entity_name) != None):
self.devices_manager.handle_mqtt_message(Devices, entity_name,
message)
elif (self.groups_manager.get_group_by_name(entity_name) != None):
self.groups_manager.handle_mqtt_message(entity_name, message)
else:
Domoticz.Debug('Unhandled message from zigbee2mqtt: ' + topic +
' ' + str(message))
class BasePlugin:
enabled = False
mqttConn = None
counter = 0
def __init__(self):
return
def onStart(self):
if Parameters["Mode6"] == "Debug":
Domoticz.Debugging(1)
DumpConfigToLog()
self.devices = {}
Parameters["Username"] = "******"
Parameters["Port"] = "8884"
Parameters["Protocol"] = "MQTTS"
mqtt_server_address = Parameters["Address"].strip()
mqtt_server_port = Parameters["Port"].strip()
self.mqttClient = MqttClient(mqtt_server_address, mqtt_server_port,
"NHCDomoticz", self.onMQTTConnected,
self.onMQTTDisconnected,
self.onMQTTPublish, self.onMQTTSubscribed)
def onStop(self):
Domoticz.Debug("onStop called")
def onCommand(self, Unit, Command, Level, Hue):
for uuid, device in self.devices.items():
if device.getUnit() == Unit:
device.handleCommand(Command, Level, Hue)
#MQTT forwards..
def onConnect(self, Connection, Status, Description):
self.mqttClient.onConnect(Connection, Status, Description)
def onMessage(self, Connection, Data):
self.mqttClient.onMessage(Connection, Data)
def onDisconnect(self, Connection):
self.mqttClient.onDisconnect(Connection)
def onHeartbeat(self):
self.mqttClient.onHeartbeat()
# MQTT stuff
def onMQTTConnected(self):
self.mqttClient.subscribe(['hobby/control/devices/rsp'])
self.mqttClient.subscribe(['hobby/control/devices/evt'])
self.mqttClient.subscribe(['hobby/control/devices/err'])
# fetch all devices
self.mqttClient.publish('hobby/control/devices/cmd',
'{"Method": "devices.list"}')
def onMQTTDisconnected(self):
Domoticz.Log("onMQTT disconnected")
def onMQTTSubscribed(self):
Domoticz.Log("onMQTTSubscribed")
def onMQTTPublish(self, topic, message):
if topic == "hobby/control/devices/rsp":
if message["Params"]:
nhcDeviceIDs = []
if message["Params"][0]["Devices"]:
for device in message["Params"][0]["Devices"]:
if device["Type"] == "action":
uuid = device["Uuid"]
self.devices[uuid] = Device(
Devices, device, self.mqttClient)
self.devices[uuid].handleMessage(topic, device)
if topic == "hobby/control/devices/evt":
if message["Method"] == "devices.status":
if message["Params"]:
if message["Params"][0]["Devices"]:
for device in message["Params"][0]["Devices"]:
uuid = device["Uuid"]
if uuid in self.devices:
self.devices[uuid].handleMessage(topic, device)
if topic == "hobby/control/devices/err":
Domoticz.Log("Err")
if key == keyboard.Key.esc:
# Stop listener
return False
def start():
with keyboard.Listener(on_press=on_press,
on_release=on_release) as listener:
listener.join()
if __name__ == "__main__":
logger.info("########## OBD Tracker ##########")
logger.info("MqttClient is connecting to the broker")
mqtt_client = MqttClient()
mqtt_client.connect()
obd_tracker = OBDTracker(mqtt_client=mqtt_client)
obd_tracker.connect()
obd_tracker.test_query()
start()
logger.info("Shutting down the OBDTracker...")
obd_tracker.shut_down(reason="Shut down requested")
logger.info("Shutting down the MqttClient...")
mqtt_client.shut_down()
# import asyncio
# loop = asyncio.get_event_loop()
from mqtt import MqttClient
from actions import EmitPresence, EmitStatus, ButtonHandler, EmitFood, EmitCoffee
from ruamel.yaml import YAML
LOGGER = logging.getLogger('lamp')
logging.basicConfig(level=logging.INFO,
format="[%(asctime)s] %(levelname)s:%(name)s:%(message)s")
CONFIG_PATH = os.path.join('./', 'config.yaml')
LOGGER.info("Loading config: " + CONFIG_PATH)
CONFIG = YAML(typ='safe').load(open(CONFIG_PATH))
jenkins = JenkinsClient(CONFIG['jenkins'])
hipchat = Hipchat(CONFIG['hipchat'])
mqtt = MqttClient(CONFIG['mqtt'])
EMITTERS = [
EmitStatus(mqtt, jenkins, CONFIG['jenkins']['topic']),
EmitPresence(mqtt, hipchat, CONFIG['hipchat']['topic']),
EmitFood(mqtt, CONFIG['lunching']),
EmitCoffee(mqtt, CONFIG['coffee'])
]
ButtonHandler(mqtt, hipchat, CONFIG['button'])
# import code; code.interact(local=dict(globals(), **locals()))
try:
while True:
for emitter in EMITTERS:
class Plugin:
mqttClient = None
tasmotaHandler = None
def __init__(self):
return
def onStart(self):
if errmsg == "":
try:
Domoticz.Heartbeat(10)
self.debugging = Parameters["Mode6"]
if self.debugging == "Verbose":
Domoticz.Debugging(2 + 4 + 8 + 16 + 64)
if self.debugging == "Debug":
Domoticz.Debugging(2)
global pluginDebug
pluginDebug = False
setTasmotaDebug(True)
setMqttDebug(False)
Debug("Plugin::onStart: Parameters: {}".format(
repr(Parameters)))
self.mqttserveraddress = Parameters["Address"].strip()
self.mqttserverport = Parameters["Port"].strip()
self.mqttClient = MqttClient(
self.mqttserveraddress, self.mqttserverport,
Parameters["Mode5"], self.onMQTTConnected,
self.onMQTTDisconnected, self.onMQTTPublish,
self.onMQTTSubscribed)
self.mqttClient.debug(False)
self.tasmotaHandler = Handler(
Parameters["Mode4"].strip().split('|'),
Parameters["Mode1"].strip(), Parameters["Mode2"].strip(),
Parameters["Mode3"].strip(), self.mqttClient, Devices)
self.tasmotaHandler.debug(True)
except Exception as e:
Domoticz.Error("Plugin::onStart: {}".format(str(e)))
self.mqttClient = None
else:
Domoticz.Error(
"Plugin::onStart: Domoticz Python env error {}".format(errmsg))
self.mqttClient = None
def debug(self, flag):
global pluginDebug
pluginDebug = flag
def checkDevices(self):
Debug("Plugin::checkDevices")
# Let tasmotaHandler react to commands from Domoticz
def onCommand(self, Unit, Command, Level, Color):
if self.mqttClient is None:
return False
return self.tasmotaHandler.onDomoticzCommand(Unit, Command, Level,
Color)
def onConnect(self, Connection, Status, Description):
Debug("Plugin::onConnect")
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):
Debug("Plugin::onHeartbeat")
if self.mqttClient is not None:
try:
# Reconnect if connection has dropped
if (self.mqttClient._connection is
None) or (not self.mqttClient.isConnected):
Debug("Plugin::onHeartbeat: Reconnecting")
self.mqttClient._open()
else:
self.mqttClient.ping()
except Exception as e:
Domoticz.Error("Plugin::onHeartbeat error {}".format(str(e)))
# Let tasmotaHandler subscribe its topics
def onMQTTConnected(self):
if self.mqttClient is not None:
self.tasmotaHandler.onMQTTConnected()
def onMQTTDisconnected(self):
Debug("Plugin::onMQTTDisconnected")
def onMQTTSubscribed(self):
Debug("Plugin::onMQTTSubscribed")
# Let tasmotaHandler process incoming MQTT messages
def onMQTTPublish(self, topic, message):
return self.tasmotaHandler.onMQTTPublish(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.install()
self.base_topic = Parameters["Mode1"].strip()
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.api = API(Devices, self.onApiCommand)
self.devices_manager = DevicesManager()
self.groups_manager = GroupsManager()
def checkDevices(self):
Domoticz.Debug("checkDevices called")
def onStop(self):
Domoticz.Debug("onStop called")
self.uninstall()
def onCommand(self, Unit, Command, Level, Color):
Domoticz.Debug("onCommand: " + Command + ", level (" + str(Level) + ") Color:" + Color)
message = None
device = Devices[Unit] #Devices is Domoticz collection of devices for this hardware
device_params = device.DeviceID.split('_')
entity_id = device_params[0]
if (self.devices_manager.get_device_by_id(entity_id) != None):
message = self.devices_manager.handle_command(device, Command, Level, Color)
elif(self.groups_manager.get_group_by_deviceid(device.DeviceID) != None):
message = self.groups_manager.handle_command(device, Command, Level, Color)
else:
Domoticz.Log('Can\'t process command from device "' + device.Name + '"')
if (message != None):
self.publishToMqtt(message['topic'], message['payload'])
def onApiCommand(self, command, data):
if command == 'publish_mqtt':
return self.publishToMqtt(data['topic'], data['payload'])
elif command == 'remove_device':
return self.devices_manager.remove(data)
else:
Domoticz.Error('Internal API command "' + command +'" is not supported by plugin')
def publishToMqtt(self, topic, payload):
self.mqttClient.publish(self.base_topic + '/' + topic, payload)
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 onDeviceModified(self, unit):
if (unit == 255):
self.api.handle_request(Devices[unit].sValue)
return
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 + '/#'])
def onMQTTDisconnected(self):
Domoticz.Debug('Disconnected from MQTT server')
def onMQTTSubscribed(self):
Domoticz.Debug('Subscribed to "' + self.base_topic + '/#" topic')
def onMQTTPublish(self, topic, message):
# Domoticz.Debug("MQTT message: " + topic + " " + str(message))
topic = topic.replace(self.base_topic + '/', '')
self.api.handle_mqtt_message(topic, message)
if (topic == 'bridge/config/permit_join'):
return
if (topic == 'bridge/config/logging'):
# TODO: Add log feature
return
if (topic == 'bridge/devices'):
Domoticz.Log('Received available devices list from bridge')
self.devices_manager.set_devices(message)
return
if (topic == 'bridge/config'):
permit_join = 'enabled' if message['permit_join'] else 'disabled'
Domoticz.Debug('Zigbee2mqtt log level is ' + message['log_level'])
Domoticz.Log('Joining new devices is ' + permit_join + ' on the zigbee bridge')
return
if (topic == 'bridge/state'):
Domoticz.Log('Zigbee2mqtt bridge is ' + message)
if message == 'online':
# self.publishToMqtt('bridge/config/devices', '')
self.publishToMqtt('bridge/config/groups', '')
return
if (topic == 'bridge/log'):
is_connected = message['type'] == 'device_connected'
is_removed = message['type'] == 'device_removed'
is_paired = message['type'] == 'pairing' and message['message'] == 'interview_successful'
if message['type'] == 'groups':
Domoticz.Log('Received groups list from bridge')
self.groups_manager.register_groups(message['message'])
if is_connected or is_removed or is_paired:
self.publishToMqtt('bridge/config/devices/get', '')
if message['type'] == 'ota_update':
Domoticz.Log(message['message'])
if message['type'] == 'zigbee_publish_error':
#an error occured on publish to the zigbee network
deviceMeta = message['meta']
Domoticz.Error("A Zigbee publish error occured for device '" + deviceMeta['friendly_name'] + "' with error message: " + message['message'])
return
if (self.devices_manager.get_device_by_name(topic) != None):
self.devices_manager.handle_mqtt_message(topic, message)
elif (self.groups_manager.get_group_by_name(topic) != None):
self.groups_manager.handle_mqtt_message(topic, message)
def install(self):
Domoticz.Log('Installing plugin custom page...')
try:
source_path = Parameters['HomeFolder'] + 'frontend'
templates_path = Parameters['StartupFolder'] + 'www/templates'
dst_plugin_path = templates_path + '/zigbee2mqtt'
Domoticz.Debug('Copying files from ' + source_path + ' to ' + templates_path)
if not (os.path.isdir(dst_plugin_path)):
os.makedirs(dst_plugin_path)
copy2(source_path + '/zigbee2mqtt.html', templates_path)
copy2(source_path + '/zigbee2mqtt.js', templates_path)
copy2(source_path + '/zigbee_devices.js', dst_plugin_path)
copy2(source_path + '/zigbee_groups.js', dst_plugin_path)
copy2(source_path + '/libs/leaflet.js', dst_plugin_path)
copy2(source_path + '/libs/leaflet.css', dst_plugin_path)
copy2(source_path + '/libs/viz.js', dst_plugin_path)
copy2(source_path + '/libs/viz.full.render.js', dst_plugin_path)
Domoticz.Log('Installing plugin custom page completed.')
except Exception as e:
Domoticz.Error('Error during installing plugin custom page')
Domoticz.Error(repr(e))
def uninstall(self):
Domoticz.Log('Uninstalling plugin custom page...')
try:
templates_path = Parameters['StartupFolder'] + 'www/templates'
dst_plugin_path = templates_path + '/zigbee2mqtt'
Domoticz.Debug('Removing files from ' + templates_path)
if (os.path.isdir(dst_plugin_path)):
rmtree(dst_plugin_path)
if os.path.exists(templates_path + "/zigbee2mqtt.html"):
os.remove(templates_path + "/zigbee2mqtt.html")
if os.path.exists(templates_path + "/zigbee2mqtt.js"):
os.remove(templates_path + "/zigbee2mqtt.js")
Domoticz.Log('Uninstalling plugin custom page completed.')
except Exception as e:
Domoticz.Error('Error during uninstalling plugin custom page')
Domoticz.Error(repr(e))
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.install()
self.base_topic = Parameters["Mode1"].strip()
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.api = API(Devices, self.publishToMqtt)
self.devices_manager = DevicesManager()
self.groups_manager = GroupsManager()
def checkDevices(self):
Domoticz.Debug("checkDevices called")
def onStop(self):
Domoticz.Debug("onStop called")
self.uninstall()
def onCommand(self, Unit, Command, Level, Color):
Domoticz.Debug("onCommand: " + Command + ", level (" + str(Level) +
") Color:" + Color)
message = None
device = Devices[
Unit] #Devices is Domoticz collection of devices for this hardware
device_params = device.DeviceID.split('_')
entity_id = device_params[0]
if (self.devices_manager.get_device_by_id(entity_id) != None):
message = self.devices_manager.handle_command(
Devices, device, Command, Level, Color)
elif (self.groups_manager.get_group_by_deviceid(device.DeviceID) !=
None):
message = self.groups_manager.handle_command(
device, Command, Level, Color)
else:
Domoticz.Log('Can\'t process command from device "' + device.Name +
'"')
if (message != None):
self.publishToMqtt(message['topic'], message['payload'])
def publishToMqtt(self, topic, payload):
self.mqttClient.publish(self.base_topic + '/' + topic, payload)
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 onDeviceModified(self, unit):
if (unit == 255):
self.api.handle_request(Devices[unit].sValue)
return
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):
self.subscribed_for_devices = False
def onMQTTSubscribed(self):
Domoticz.Debug("onMQTTSubscribed")
def onMQTTPublish(self, topic, message):
Domoticz.Debug("MQTT message: " + topic + " " + str(message))
topic = topic.replace(self.base_topic + '/', '')
self.api.handle_mqtt_message(topic, message)
if (topic == 'bridge/config/permit_join'
or topic == 'bridge/config/devices'):
return
if (topic == 'bridge/config'):
permit_join = 'enabled' if message['permit_join'] else 'disabled'
Domoticz.Debug('Zigbee2mqtt log level is ' + message['log_level'])
Domoticz.Log('Joining new devices is ' + permit_join +
' on the zigbee bridge')
return
if (topic == 'bridge/state'):
Domoticz.Log('Zigbee2mqtt bridge is ' + message)
if message == 'online':
self.publishToMqtt('bridge/config/devices', '')
self.publishToMqtt('bridge/config/groups', '')
return
if (topic == 'bridge/log'):
if message['type'] == 'devices':
Domoticz.Log('Received available devices list from bridge')
self.devices_manager.clear()
self.devices_manager.update(Devices, message['message'])
if self.subscribed_for_devices == False:
self.mqttClient.subscribe([self.base_topic + '/+'])
self.subscribed_for_devices = True
if message['type'] == 'groups':
Domoticz.Log('Received groups list from bridge')
self.groups_manager.register_groups(Devices,
message['message'])
if message['type'] == 'device_connected' or message[
'type'] == 'device_removed':
self.publishToMqtt('bridge/config/devices', '')
if message['type'] == 'ota_update':
Domoticz.Log(message['message'])
return
if (self.devices_manager.get_device_by_name(topic) != None):
self.devices_manager.handle_mqtt_message(Devices, topic, message)
elif (self.groups_manager.get_group_by_name(topic) != None):
self.groups_manager.handle_mqtt_message(topic, message)
def install(self):
Domoticz.Log('Installing plugin custom page...')
try:
source_path = os.path.dirname(
os.path.abspath(__file__)) + '/frontend'
templates_path = os.path.abspath(source_path +
'/../../../www/templates')
dst_plugin_path = templates_path + '/zigbee2mqtt'
Domoticz.Debug('Copying files from ' + source_path + ' to ' +
templates_path)
if not (os.path.isdir(dst_plugin_path)):
os.makedirs(dst_plugin_path)
copy2(source_path + '/zigbee2mqtt.html', templates_path)
copy2(source_path + '/zigbee2mqtt.js', templates_path)
copy2(source_path + '/zigbee_devices.js', dst_plugin_path)
copy2(source_path + '/zigbee_groups.js', dst_plugin_path)
copy2(source_path + '/libs/leaflet.js', dst_plugin_path)
copy2(source_path + '/libs/leaflet.css', dst_plugin_path)
copy2(source_path + '/libs/viz.js', dst_plugin_path)
copy2(source_path + '/libs/viz.full.render.js', dst_plugin_path)
Domoticz.Log('Installing plugin custom page completed.')
except Exception as e:
Domoticz.Error('Error during installing plugin custom page')
Domoticz.Error(repr(e))
def uninstall(self):
Domoticz.Log('Uninstalling plugin custom page...')
try:
templates_path = os.path.abspath(
os.path.dirname(os.path.abspath(__file__)) +
'/../../www/templates')
dst_plugin_path = templates_path + '/zigbee2mqtt'
Domoticz.Debug('Removing files from ' + templates_path)
if (os.path.isdir(dst_plugin_path)):
rmtree(dst_plugin_path)
if os.path.exists(templates_path + "/zigbee2mqtt.html"):
os.remove(templates_path + "/zigbee2mqtt.html")
if os.path.exists(templates_path + "/zigbee2mqtt.js"):
os.remove(templates_path + "/zigbee2mqtt.js")
Domoticz.Log('Uninstalling plugin custom page completed.')
except Exception as e:
Domoticz.Error('Error during uninstalling plugin custom page')
Domoticz.Error(repr(e))
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)
from workers_manager import WorkersManager
parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument('-d', '--debug', action='store_true', default=False)
group.add_argument('-q', '--quiet', action='store_true', default=False)
parsed = parser.parse_args()
if parsed.debug:
_LOGGER.setLevel(logging.DEBUG)
else:
_LOGGER.setLevel(logging.INFO)
_LOGGER.debug('Starting')
mqtt = MqttClient(settings['mqtt'])
manager = WorkersManager()
manager.register_workers(settings['manager']).start(mqtt)
running = True
try:
while running:
try:
mqtt.publish(_WORKERS_QUEUE.get(block=True).execute())
except (KeyboardInterrupt, SystemExit):
raise
except Exception as e:
if not parsed.quiet:
_LOGGER.exception(e)
except KeyboardInterrupt:
