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 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 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 __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()
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))
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)
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 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.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 parseValues(overview):
# Running in the main thread
deviceManager = DeviceManager(self.context)
self.armState = overview.get('armState', {}).get('statusType', '')
# Main box
if self.alarmDevice.updateStatus(overview['armState']):
# Send signal
self.verisureArmStateChanged(overview['armState']['date'], overview['armState']['statusType'], overview['armState']['name'], overview['armState']['changedVia'])
# Door/Window sensors
for door in overview.get('doorWindow', {}).get('doorWindowDevice', []):
deviceLabel = door['deviceLabel']
if deviceLabel not in self.devices:
device = DoorWindowDevice(door)
self.devices[deviceLabel] = device
deviceManager.addDevice(device)
else:
device = self.devices[deviceLabel]
device.updateStatus(door)
# Climate values
for climate in overview.get('climateValues', []):
deviceLabel = climate['deviceLabel']
if deviceLabel not in self.devices:
device = ClimateDevice(climate)
self.devices[deviceLabel] = device
deviceManager.addDevice(device)
else:
device = self.devices[deviceLabel]
device.updateValues(climate)
# Smart plugs
for plug in overview.get('smartPlugs', []):
deviceLabel = plug['deviceLabel']
if deviceLabel not in self.devices:
device = SmartPlugDevice(plug, self)
self.devices[deviceLabel] = device
deviceManager.addDevice(device)
else:
device = self.devices[deviceLabel]
device.updateValues(plug)
# Door locks
for lock in overview.get('doorLockStatusList', []):
deviceLabel = lock['deviceLabel']
if deviceLabel not in self.devices:
device = DoorLockDevice(lock)
self.devices[deviceLabel] = device
deviceManager.addDevice(device)
else:
device = self.devices[deviceLabel]
device.updateStatus(lock)
if self.loaded == False:
deviceManager.finishedLoading('verisure')
self.loaded = True
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 __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()
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 __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)
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.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 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 __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)
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 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
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.deviceManager = DeviceManager(self.context)
self.devices = None
thread = Thread(target=self.detectBroadlink,
name="Detect Broadlink Devices")
thread.start()
def __init__(self):
self.deviceManager = DeviceManager(self.context)
self.sensor = None
Application().registerScheduledTask(self.__requestNewValue,
minutes=1,
runAtOnce=True)
def loadDevices(self):
deviceManager = DeviceManager(self.context)
for dev in TPLinkSmartHomeProtocol.discover():
plug = SmartPlug(dev['ip'])
deviceManager.addDevice(TPLinkDevice(plug))
deviceManager.finishedLoading('tplink')
def tearDown(self):
deviceManager = DeviceManager(self.context)
deviceManager.removeDevicesByType('shelly')
def __init__(self):
self.deviceManager = DeviceManager(self.context)
self.lifxClient = lifx.Client()
Timer(2.0, self.discover).start()
