def run_discovery(self):
self.debug('discover devices')
try:
# publish devices
publishedDevices = [self.publish_hub_device()]
deviceManager = DeviceManager(self.context)
devices = deviceManager.retrieveDevices()
for device in devices:
try:
self.debug(json.dumps({
'deviceId': device.id(),
'type': self.getDeviceType(device),
'name': device.name(),
'isDevice': device.isDevice(),
'isSensor': device.isSensor(),
'methods': device.methods(),
'battery': device.battery(),
'parameters': device.allParameters() if hasattr(device, 'allParameters') else device.parameters(),
'typeStr': device.typeString(),
'sensors': device.sensorValues(),
'state': device.state()
}))
publishedDevices.extend(self.discovery(device))
except Exception as e:
self.debug('run_discovery device exception %s' % str(e))
for type, devId, fullId in list(set(self.getKnownDevices()) - set(publishedDevices)):
self.remove_discovery(type, devId, fullId)
self.setKnownDevices(publishedDevices)
except Exception as e:
self.debug('run_discovery exception %s' % str(e))
class Eliq(Plugin):
def __init__(self):
self.deviceManager = DeviceManager(self.context)
self.sensor = None
Application().registerScheduledTask(self.__requestNewValue,
minutes=1,
runAtOnce=True)
def __requestNewValue(self):
accessToken = self.config('accessToken')
if accessToken == '':
return
try:
eliq = eliqonline.API(accessToken)
data_now = eliq.get_data_now()
except HTTPError as e:
# Something wrong with our request apparantly
logging.error('Could not request Eliq value %s', e)
return
except Exception as e:
# Something wrong with our request apparantly
logging.error('Could not request Eliq value %s', e)
return
if self.sensor is None:
self.sensor = EliqSensor(data_now.channelid)
self.sensor.setSensorValue(Sensor.WATT, data_now.power,
Sensor.SCALE_POWER_WATT)
self.deviceManager.addDevice(self.sensor)
self.deviceManager.finishedLoading('eliq')
else:
self.sensor.setSensorValue(Sensor.WATT, data_now.power,
Sensor.SCALE_POWER_WATT)
def onMessage(self, client, userdata, msg):
try:
#topic = msg.topic
payload = msg.payload
#topicType = topic.split('/')[-1]
deviceManager = DeviceManager(userdata.context)
device_id = int(msg.topic.split('/')[-2])
device = deviceManager.device(device_id)
deviceType = userdata.getDeviceType(device)
if not deviceType:
return
userdata.debug(json.dumps({
'type': 'command',
'device_id': device_id,
'device_type': deviceType,
'command': payload
}))
if deviceType == 'light':
payload = json.loads(payload)
if 'brightness' in payload:
if int(payload['brightness']) == 0:
device.command(
Device.TURNOFF,
origin = 'mqtt_hass'
)
else:
device.command(
Device.DIM,
value = int(payload['brightness']),
origin = 'mqtt_hass'
)
else:
device.command(
Device.TURNON if payload['state'].upper() == 'ON' \
else Device.TURNOFF,
value = 255,
origin = 'mqtt_hass'
)
elif deviceType == 'switch':
device.command(
Device.TURNON if payload.upper() == 'ON' \
else Device.BELL if payload.upper() == 'BELL' \
else Device.TURNOFF,
origin = 'mqtt_hass'
)
elif deviceType == 'cover':
device.command(
Device.UP if payload.upper() == 'OPEN' \
else Device.DOWN if payload.upper() == 'CLOSE' else \
Device.STOP,
origin = 'mqtt_hass'
)
except Exception as e:
userdata.debug('onMessage exception %s' % str(e))
def loadAccessories(self): self.accessories[1] = HapBridgeAccessory() deviceManager = DeviceManager(HapConnection.HTTPDServer.context) for device in deviceManager.retrieveDevices(): if not device.confirmed(): continue self.deviceAdded(device)
def __init__(self):
self.version = 0
self.hwVersion = None
self.devices = []
self.sensors = []
self.rawEnabled = False
self.rawEnabledAt = 0
self.dev = Adapter(self, Board.rf433Port())
deviceNode = DeviceNode(self.dev)
self.deviceManager = DeviceManager(self.context)
for d in self.deviceManager.retrieveDevices('433'):
p = d.params()
if 'type' not in p:
continue
if p['type'] == 'sensor':
device = SensorNode()
self.sensors.append(device)
elif p['type'] == 'device':
device = DeviceNode(self.dev)
self.devices.append(device)
else:
continue
device.setNodeId(d.id())
device.setParams(p)
self.deviceManager.addDevice(device)
self.deviceManager.finishedLoading('433')
self.dev.queue(
RF433Msg('V', success=self.__version, failure=self.__noVersion))
self.dev.queue(
RF433Msg('H', success=self.__hwVersion,
failure=self.__noHWVersion))
self.live = TelldusLive(self.context)
def __init__(self):
self.running = False
#self.runningJobsLock = threading.Lock() #TODO needed?
self.jobsLock = threading.Lock()
self.maintenanceJobsLock = threading.Lock()
self.maintenanceJobs = []
self.lastMaintenanceJobId = 0
self.runningJobs = {} #id:s as keys
self.settings = Settings('telldus.scheduler')
Application().registerShutdown(self.stop)
Application().registerMaintenanceJobHandler(
self.addMaintenanceJobGeneric)
self.timezone = self.settings.get('tz', 'UTC')
self.latitude = self.settings.get('latitude', '55.699592')
self.longitude = self.settings.get('longitude', '13.187836')
self.jobs = []
self.fetchLocalJobs()
self.live = TelldusLive(self.context)
self.deviceManager = DeviceManager(self.context)
if self.live.isRegistered():
#probably not practically possible to end up here
self.requestJobsFromServer()
self.thread = threading.Thread(target=self.run)
self.thread.start()
class SqueezeBox(Plugin):
def __init__(self):
self.deviceManager = DeviceManager(self.context)
self.loaded = False
if self.config('hostname') != '':
self.setHostname(self.config('hostname'))
def configWasUpdated(self, key, value):
if key == 'hostname':
self.setHostname(value)
def setHostname(self, hostname):
if self.loaded:
logging.warning('Cannot change hostname, without a restart')
return
self.sc = Server(hostname=hostname)
try:
self.sc.connect()
except:
logging.error("Cannot connect to squeezebox server")
return
for player in self.sc.players:
self.deviceManager.addDevice(Player(player))
self.deviceManager.finishedLoading('squeezebox')
self.loaded = True
def __init__(self):
self.loaded = False
self.armState = None
self.alarmDevice = AlarmDevice()
deviceManager = DeviceManager(self.context)
deviceManager.addDevice(self.alarmDevice)
self.devices = {}
Application().registerScheduledTask(fn=self.__fetch, minutes=10, runAtOnce=True)
def __init__(self):
self.scenes = {}
self.deviceManager = DeviceManager(self.context)
for sceneId in self.config('scenes'):
device = SceneDevice(sceneId)
self.scenes[sceneId] = device
self.deviceManager.addDevice(device)
self.deviceManager.finishedLoading('scene')
def __init__(self):
self.deviceManager = DeviceManager(self.context)
self.client = mqtt.Client('telldus')
self.client.on_connect = self.onConnect
self.client.on_message = self.onMessage
self.client.on_publish = self.onPublish
self.client.on_subscribe = self.onSubscribe
if self.config('hostname') != '':
self.connect()
class Group(Plugin):
implements(ITelldusLiveObserver)
def __init__(self):
self.devices = []
self.deviceManager = DeviceManager(self.context)
for d in self.deviceManager.retrieveDevices('group'):
p = d.params()
device = GroupDevice()
self.devices.append(device)
device.setNodeId(d.id())
device.setParams(p)
self.deviceManager.addDevice(device)
self.deviceManager.finishedLoading('group')
self.live = TelldusLive(self.context)
def addDevice(self, name, devices):
if type(devices) != list:
return
device = GroupDevice()
device.setName(name)
device.setParams({
'devices': devices
})
self.devices.append(device)
self.deviceManager.addDevice(device)
@TelldusLive.handler('group')
def __handleCommand(self, msg):
data = msg.argument(0).toNative()
action = data['action']
if action == 'addGroup':
self.addDevice(data['name'], data['devices'])
elif action == 'editGroup':
deviceId = data['device']
for device in self.devices:
if device.id() == deviceId:
device.setParams({
'devices': data['devices'],
})
device.paramUpdated('')
break
elif action == 'groupInfo':
deviceId = data['device']
for device in self.devices:
if device.id() == deviceId:
params = device.params()
params['deviceId'] = deviceId
self.live.pushToWeb('group', 'groupInfo', params)
return
elif action == 'remove':
deviceId = data['device']
for device in self.devices:
if device.id() == deviceId:
self.deviceManager.removeDevice(deviceId)
self.devices.remove(device)
return
def __init__(self):
# The devicemanager is a globally manager handling all device types
self.deviceManager = DeviceManager(self.context)
# Load all devices this plugin handles here. Individual settings for the devices
# are handled by the devicemanager
self.deviceManager.addDevice(DummyDevice())
# When all devices has been loaded we need to call finishedLoading() to tell
# the manager we are finished. This clears old devices and caches
self.deviceManager.finishedLoading('dummy')
def __init__(self):
self.devices = []
self.deviceManager = DeviceManager(self.context) # pylint: disable=too-many-function-args
for oldDevice in self.deviceManager.retrieveDevices('group'):
params = oldDevice.params()
device = GroupDevice()
self.devices.append(device)
device.setNodeId(oldDevice.id())
device.setParams(params)
self.deviceManager.addDevice(device)
self.deviceManager.finishedLoading('group')
self.live = TelldusLive(self.context) # pylint: disable=too-many-function-args
def __init__(self):
self.devices = []
self.deviceManager = DeviceManager(self.context)
for d in self.deviceManager.retrieveDevices('group'):
p = d.params()
device = GroupDevice()
self.devices.append(device)
device.setNodeId(d.id())
device.setParams(p)
self.deviceManager.addDevice(device)
self.deviceManager.finishedLoading('group')
self.live = TelldusLive(self.context)
def __init__(self):
self.deviceManager = DeviceManager(self.context)
self.username = None
self.ssdp = None
config = self.config('bridge')
self.activated = config.get('activated', False)
self.username = config.get('username', '')
self.bridge = config.get('bridge', '')
self.state = Hue.STATE_NO_BRIDGE
self.lights = {}
self.ssdp = SSDP(self.context)
if self.activated:
Application().queue(self.selectBridge, config.get('bridge'))
Application().registerScheduledTask(self.update, minutes=1)
def __init__(self):
self.deviceManager = DeviceManager(self.context)
self.sensors = {}
self.loaded = False
self.clientId = ''
self.clientSecret = ''
config = self.config('oauth')
self.accessToken = config.get('accessToken', '')
self.refreshToken = config.get('refreshToken', '')
if self.accessToken is not '':
self.configuration['oauth'].activated = True
self.tokenTTL = config.get('tokenTTL', 0)
Application().registerScheduledTask(self.__requestNewValues,
minutes=10,
runAtOnce=True)
class Lifx(Plugin):
def __init__(self):
self.deviceManager = DeviceManager(self.context)
self.lifxClient = lifx.Client()
Timer(2.0, self.discover).start()
@mainthread
def discover(self):
for light in self.lifxClient.get_devices():
try:
d = LifxDevice(light)
except Exception:
continue
self.deviceManager.addDevice(d)
self.deviceManager.finishedLoading('lifx')
def __init__(self):
# The devicemanager is a globally manager handling all device types
self.deviceManager = DeviceManager(self.context)
# Load all devices this plugin handles here. Individual settings for the devices
# are handled by the devicemanager
self.sensor = TemperatureSensor()
self.deviceManager.addDevice(self.sensor)
# When all devices has been loaded we need to call finishedLoading() to tell
# the manager we are finished. This clears old devices and caches
self.deviceManager.finishedLoading('temperature')
Application().registerScheduledTask(self.updateValues,
minutes=1,
runAtOnce=True)
def discover(self):
self.discovered_flag = False
self._debug('Discovering devices ...')
self.devices = self.staticDevices + []
devMgr = DeviceManager(self.context)
for device in devMgr.retrieveDevices():
haDevs = devs.createDevices(device, self.hub, self._buildTopic,
self.config('use_via'))
self._debug('Discovered %s' %
json.dumps(self._debugDevice(device, haDevs)))
for haDev in haDevs:
self.devices.append(haDev)
self.discovered_flag = True
self._debug('Discovered %s devices' % len(self.devices))
Application().queue(self.cleanupDevices)
def __init__(self):
self.last_sent_data = None
self.stop_ping_loop = threading.Event()
self.deviceManager = DeviceManager(self.context)
Application().registerShutdown(self.shutdown)
settings = Settings('tellduslive.config')
self.uuid = settings['uuid']
self.logHandler = ShellyLogger(self.uuid)
LOGGER.addHandler(self.logHandler)
self.setupPing()
LOGGER.info('Init Shelly ' + __version__)
self._initPyShelly()
def __loadCached(self):
deviceManager = DeviceManager(self.context)
l = deviceManager.retrieveDevices('sonos')
if len(l) == 0:
# No cached, retry search in 10 minutes
timer = Timer(600, self.__scanDevices)
timer.daemon = True
timer.start()
return
for dev in l:
ip = dev.params().get('ip_address', None)
if ip is None:
continue
try:
s = soco.SoCo(ip)
s.uid # Will throw exception if not available
deviceManager.addDevice(SonosDevice(s))
except ConnectionError:
continue
def __init__(self):
self.version = 0
self.hwVersion = None
self.devices = []
self.sensors = []
self.rawEnabled = False
self.rawEnabledAt = 0
self.dev = Adapter(self, Board.rf433Port())
self.deviceManager = DeviceManager(self.context)
self.registerSensorCleanup()
for dev in self.deviceManager.retrieveDevices('433'):
params = dev.params()
if 'type' not in params:
continue
if params['type'] == 'sensor':
device = SensorNode()
self.sensors.append(device)
elif params['type'] == 'device':
device = DeviceNode(self.dev) # pylint: disable=R0204
self.devices.append(device)
else:
continue
device.setNodeId(dev.id())
device.setParams(params)
if params['type'] == 'sensor':
# already loaded, keep it that way!
device._packageCount = 7 # pylint: disable=W0212
device._sensorValues = dev._sensorValues # pylint: disable=W0212
device.batteryLevel = dev.batteryLevel
if hasattr(dev, 'declaredDead'):
device.declaredDead = dev.declaredDead
self.deviceManager.addDevice(device)
self.deviceManager.finishedLoading('433')
self.dev.queue(
RF433Msg('V', success=self.__version, failure=self.__noVersion))
self.dev.queue(
RF433Msg('H', success=self.__hwVersion,
failure=self.__noHWVersion))
self.live = TelldusLive(self.context)
def __init__(self):
self.sensor = YRSensor()
deviceManager = DeviceManager(self.context)
deviceManager.addDevice(self.sensor)
deviceManager.finishedLoading('yr')
Application().registerScheduledTask(self.__requestWeather,
hours=1,
runAtOnce=True)
class WeMo(Plugin):
def __init__(self):
self.devices = {}
self.deviceManager = DeviceManager(self.context)
Thread(target=self.discover).start()
def addDevice(self, DeviceType, device):
if device.serialnumber in self.devices:
return
d = DeviceType(device)
self.deviceManager.addDevice(d)
self.devices[device.serialnumber] = d
def bridgeFound(self, bridge):
if bridge.serialnumber in self.devices:
return
self.devices[bridge.serialnumber] = bridge
for light in bridge.Lights:
d = WeMoLight(bridge.Lights[light])
self.deviceManager.addDevice(d)
def discover(self):
devices = pywemo.discover_devices()
for device in devices:
if isinstance(device, pywemo.Bridge):
Application().queue(self.bridgeFound, device)
elif isinstance(device, pywemo.Switch):
Application().queue(self.switchFound, device)
elif isinstance(device, pywemo.Motion):
Application().queue(self.motionFound, device)
Application().queue(self.deviceManager.finishedLoading, 'wemo')
def motionFound(self, motion):
logging.info("WeMo motion found: %s", motion)
# TODO(micke): Implement this when we have a sample
def switchFound(self, switch):
self.addDevice(WeMoSwitch, switch)
def createTrigger(self, type, **kwargs): # pylint: disable=W0622
if type == 'blockheater':
trigger = BlockheaterTrigger(factory=self,
manager=self.triggerManager,
deviceManager=DeviceManager(
self.context),
**kwargs)
self.blockheaterTriggers.append(trigger)
return trigger
if type == 'time':
return TimeTrigger(manager=self.triggerManager, **kwargs)
if type == 'suntime':
return SuntimeTrigger(manager=self.triggerManager, **kwargs)
return None
def discover(self):
deviceManager = DeviceManager(self.context)
for light in self.lifxClient.get_devices():
try:
device = LifxDevice(light)
except Exception:
continue
deviceManager.addDevice(device)
deviceManager.finishedLoading('lifx')
def __init__(self):
self.lastCheckedDate = None
self.device = HolidayDevice()
deviceManager = DeviceManager(self.context)
deviceManager.addDevice(self.device)
deviceManager.finishedLoading('holiday')
Application().registerScheduledTask(self.checkDay,
minutes=1,
runAtOnce=False)
def __scanDevices(self):
l = soco.discover()
if l is None:
# No found, this could be an error. Don't remove all old. Try to check them manually
self.__loadCached()
return
deviceManager = DeviceManager(self.context)
for s in l:
deviceManager.addDevice(SonosDevice(s))
deviceManager.finishedLoading('sonos')
def createTrigger(self, type, **kwargs):
if type == 'blockheater':
trigger = BlockheaterTrigger(factory=self,
manager=self.triggerManager,
deviceManager=DeviceManager(
self.context),
**kwargs)
self.blockheaterTriggers.append(trigger)
return trigger
if type == 'time':
trigger = TimeTrigger(manager=self.triggerManager, **kwargs)
return trigger
if type == 'suntime':
trigger = SuntimeTrigger(manager=self.triggerManager, **kwargs)
return trigger
return None
class Broadlink(Plugin):
def __init__(self):
self.deviceManager = DeviceManager(self.context)
self.devices = None
thread = Thread(target=self.detectBroadlink,
name="Detect Broadlink Devices")
thread.start()
def detectBroadlink(self):
self.devices = broadlink.discover(timeout=5)
for device in self.devices:
self.deviceManager.addDevice(BroadDevice(device))
self.deviceManager.finishedLoading('broadlink')
Application().registerScheduledTask(self.updateValues,
seconds=300,
runAtOnce=True)
def tearDown(self):
self.deviceManager.removeDevicesByType('broadlink')
def updateValues(self):
for device in self.deviceManager.retrieveDevices("broadlink"):
device.updateValue()
