def setup(self): # Callback dispatcher # -------------------- # Dispatcher for use with the event loop available in Python 3.4+. # Callbacks will be dispatched on the thread running the event loop. # The loop argument should be a BaseEventLoop instance, e.g. the one # returned from asyncio.get_event_loop(). dispatcher = AsyncioCallbackDispatcher(self.context.loop) # Telldus core # -------------------- # The main class for tellcore-py. Has methods for adding devices and for # enumerating controllers, devices and sensors. Also handles callbacks; # both registration and making sure the callbacks are processed in the # main thread instead of the callback thread. self.telldus = TelldusCore(callback_dispatcher=dispatcher) # Devices # -------------------- # List of configured devices in /etc/tellstick.conf self.devices = self.get_devices() # self.last_seen = {} self.state.devices = {did: d.name for did, d in self.devices.items()} # Register event callback handlers self.telldus.register_device_event(self.callbacks.device_event) self.telldus.register_device_change_event( self.callbacks.device_change_event) self.telldus.register_raw_device_event(self.callbacks.raw_event)
def setup(hass, config): """Setup the Tellstick component.""" from tellcore.constants import TELLSTICK_DIM from tellcore.telldus import AsyncioCallbackDispatcher from tellcore.telldus import TelldusCore try: tellcore_lib = TelldusCore( callback_dispatcher=AsyncioCallbackDispatcher(hass.loop)) except OSError: _LOGGER.exception('Could not initialize Tellstick') return False # Get all devices, switches and lights alike all_tellcore_devices = tellcore_lib.devices() # Register devices tellcore_registry = TellstickRegistry(hass, tellcore_lib) tellcore_registry.register_tellcore_devices(all_tellcore_devices) hass.data['tellcore_registry'] = tellcore_registry # Discover the switches _discover(hass, config, 'switch', [ tellcore_device.id for tellcore_device in all_tellcore_devices if not tellcore_device.methods(TELLSTICK_DIM) ]) # Discover the lights _discover(hass, config, 'light', [ tellcore_device.id for tellcore_device in all_tellcore_devices if tellcore_device.methods(TELLSTICK_DIM) ]) return True
def setup(hass, config): """Setup the Tellstick component.""" from tellcore.constants import TELLSTICK_DIM from tellcore.telldus import AsyncioCallbackDispatcher from tellcore.telldus import TelldusCore try: tellcore_lib = TelldusCore( callback_dispatcher=AsyncioCallbackDispatcher(hass.loop)) except OSError: _LOGGER.exception('Could not initialize Tellstick') return False # Get all devices, switches and lights alike all_tellcore_devices = tellcore_lib.devices() # Register devices tellcore_registry = TellstickRegistry(hass, tellcore_lib) tellcore_registry.register_tellcore_devices(all_tellcore_devices) hass.data['tellcore_registry'] = tellcore_registry # Discover the switches _discover(hass, config, 'switch', [tellcore_device.id for tellcore_device in all_tellcore_devices if not tellcore_device.methods(TELLSTICK_DIM)]) # Discover the lights _discover(hass, config, 'light', [tellcore_device.id for tellcore_device in all_tellcore_devices if tellcore_device.methods(TELLSTICK_DIM)]) return True
def main(): core = TelldusCore() d = core.devices()[int(sys.argv[1])] if d.last_sent_command(tellcore.constants.TELLSTICK_TURNON | tellcore.constants.TELLSTICK_TURNOFF)==tellcore.constants.TELLSTICK_TURNON: print 1 else: print 0
def setup(hass, config): """Setup the Tellstick component.""" from tellcore.constants import TELLSTICK_DIM from tellcore.library import DirectCallbackDispatcher from tellcore.telldus import TelldusCore global TELLCORE_REGISTRY try: tellcore_lib = TelldusCore( callback_dispatcher=DirectCallbackDispatcher()) except OSError: _LOGGER.exception('Could not initialize Tellstick') return False # Get all devices, switches and lights alike all_tellcore_devices = tellcore_lib.devices() # Register devices TELLCORE_REGISTRY = TellstickRegistry(hass, tellcore_lib) TELLCORE_REGISTRY.register_tellcore_devices(all_tellcore_devices) # Discover the switches _discover(hass, config, 'switch', [tellcore_device.id for tellcore_device in all_tellcore_devices if not tellcore_device.methods(TELLSTICK_DIM)]) # Discover the lights _discover(hass, config, 'light', [tellcore_device.id for tellcore_device in all_tellcore_devices if tellcore_device.methods(TELLSTICK_DIM)]) return True
def command(command, device_id): tlock.acquire(True) core = TelldusCore() if device_id < len(core.devices()): d = core.devices()[device_id] else: return "Unknow id " + str(device_id) if ((command == "E") or (command == "0") or (command == 0) or (command == "OFF") or (command == False)): command = False elif (command == "!") or (command == -1) or (command == "-1"): if d.last_sent_command(tellcore.constants.TELLSTICK_TURNON | tellcore.constants.TELLSTICK_TURNOFF ) == tellcore.constants.TELLSTICK_TURNON: command = False else: command = True else: command = True if (not command): d.turn_off() elif (command): d.turn_on() tlock.release() return d.name + " is now " + str(command)
def test_devices(self): devs = { 0: { 'protocol': b"proto_1", 'model': b"model_1" }, 3: { 'protocol': b"proto_2", 'model': b"model_2" }, 6: { 'protocol': b"proto_3", 'model': b"model_3" } } self.mocklib.tdGetNumberOfDevices = lambda: len(devs) self.mocklib.tdGetDeviceId = lambda index: index * 3 self.mocklib.tdGetDeviceType = lambda id: TELLSTICK_TYPE_DEVICE self.mocklib.tdGetProtocol = lambda id: \ c_char_p(devs[id]['protocol']) self.mocklib.tdGetModel = lambda id: \ c_char_p(devs[id]['model']) core = TelldusCore() devices = core.devices() self.assertEqual(3, len(devices)) self.assertEqual(['proto_1', 'proto_2', 'proto_3'], [d.protocol for d in devices]) self.assertEqual(['model_1', 'model_2', 'model_3'], [d.model for d in devices])
def test_group(self): self.mocklib.tdAddDevice = lambda: 1 self.mocklib.tdGetDeviceType = lambda id: TELLSTICK_TYPE_GROUP device = {} device['parameters'] = {} def tdSetName(id, name): device['name'] = self.decode_string(name) return id == 1 self.mocklib.tdSetName = tdSetName def tdSetProtocol(id, protocol): device['protocol'] = self.decode_string(protocol) return id == 1 self.mocklib.tdSetProtocol = tdSetProtocol def tdSetDeviceParameter(id, name, value): name = self.decode_string(name) if value: device['parameters'][name] = self.decode_string(value) elif name in device['parameters']: del device['parameters'][name] return id == 1 self.mocklib.tdSetDeviceParameter = tdSetDeviceParameter def tdGetDeviceParameter(id, name, default): name = self.decode_string(name) try: return c_char_p(self.encode_string(device['parameters'][name])) except KeyError: return c_char_p(default) self.mocklib.tdGetDeviceParameter = tdGetDeviceParameter core = TelldusCore() dev = core.add_group("test", [1, Device(2), 3, 4]) self.assertEqual("test", device['name']) self.assertEqual("group", device['protocol']) self.assertDictEqual({'devices': '1,2,3,4'}, device['parameters']) dev.add_to_group(5) self.assertDictEqual({'devices': '1,2,3,4,5'}, device['parameters']) dev.remove_from_group([3, 2, 6, Device(2), Device(1)]) self.assertDictEqual({'devices': '4,5'}, device['parameters']) self.assertListEqual([4, 5], [d.id for d in dev.devices_in_group()]) dev.remove_from_group(4) self.assertDictEqual({'devices': '5'}, device['parameters']) self.assertIsInstance(dev.devices_in_group()[0], DeviceGroup) dev.remove_from_group([5]) self.assertDictEqual({}, device['parameters'])
def main(): core = TelldusCore() d = core.devices()[int(sys.argv[1])] if d.last_sent_command(tellcore.constants.TELLSTICK_TURNON | tellcore.constants.TELLSTICK_TURNOFF ) == tellcore.constants.TELLSTICK_TURNON: print 1 else: print 0
def test_group(self): self.mocklib.tdAddDevice = lambda: 1 self.mocklib.tdGetDeviceType = lambda id: TELLSTICK_TYPE_GROUP device = {} device['parameters'] = {} def tdSetName(id, name): device['name'] = self.decode_string(name) return id == 1 self.mocklib.tdSetName = tdSetName def tdSetProtocol(id, protocol): device['protocol'] = self.decode_string(protocol) return id == 1 self.mocklib.tdSetProtocol = tdSetProtocol def tdSetDeviceParameter(id, name, value): name = self.decode_string(name) if value: device['parameters'][name] = self.decode_string(value) elif name in device['parameters']: del device['parameters'][name] return id == 1 self.mocklib.tdSetDeviceParameter = tdSetDeviceParameter def tdGetDeviceParameter(id, name, default): name = self.decode_string(name) try: return c_char_p(self.encode_string(device['parameters'][name])) except KeyError: return c_char_p(default) self.mocklib.tdGetDeviceParameter = tdGetDeviceParameter core = TelldusCore() dev = core.add_group("test", [1, Device(2), 3, 4]) self.assertEqual("test", device['name']) self.assertEqual("group", device['protocol']) self.assertDictEqual({'devices': '1,2,3,4'}, device['parameters']) dev.add_to_group(5) self.assertDictEqual({'devices': '1,2,3,4,5'}, device['parameters']) dev.remove_from_group([3, 2, 6, Device(2), Device(1)]) self.assertDictEqual({'devices': '4,5'}, device['parameters']) self.assertListEqual([4, 5], [d.id for d in dev.devices_in_group()]) dev.remove_from_group(4) self.assertDictEqual({'devices': '5'}, device['parameters']) self.assertIsInstance(dev.devices_in_group()[0], DeviceGroup) dev.remove_from_group([5]) self.assertDictEqual({}, device['parameters'])
def setup(hass, config): """Set up the Tellstick component.""" from tellcore.constants import TELLSTICK_DIM from tellcore.telldus import QueuedCallbackDispatcher from tellcore.telldus import TelldusCore from tellcorenet import TellCoreClient conf = config.get(DOMAIN, {}) net_host = conf.get(CONF_HOST) net_port = conf.get(CONF_PORT) # Initialize remote tellcore client if net_host and net_port: net_client = TellCoreClient(net_host, net_port) net_client.start() def stop_tellcore_net(event): """Event handler to stop the client.""" net_client.stop() hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, stop_tellcore_net) try: tellcore_lib = TelldusCore( callback_dispatcher=QueuedCallbackDispatcher()) except OSError: _LOGGER.exception("Could not initialize Tellstick") return False # Get all devices, switches and lights alike all_tellcore_devices = tellcore_lib.devices() # Register devices tellcore_registry = TellstickRegistry(hass, tellcore_lib) tellcore_registry.register_tellcore_devices(all_tellcore_devices) hass.data['tellcore_registry'] = tellcore_registry # Discover the switches _discover(hass, config, 'switch', [tellcore_device.id for tellcore_device in all_tellcore_devices if not tellcore_device.methods(TELLSTICK_DIM)]) # Discover the lights _discover(hass, config, 'light', [tellcore_device.id for tellcore_device in all_tellcore_devices if tellcore_device.methods(TELLSTICK_DIM)]) return True
def test_devices(self): devs = {0: {'protocol': b"proto_1", 'model': b"model_1"}, 3: {'protocol': b"proto_2", 'model': b"model_2"}, 6: {'protocol': b"proto_3", 'model': b"model_3"}} self.mocklib.tdGetNumberOfDevices = lambda: len(devs) self.mocklib.tdGetDeviceId = lambda index: index * 3 self.mocklib.tdGetDeviceType = lambda id: TELLSTICK_TYPE_DEVICE self.mocklib.tdGetProtocol = lambda id: \ c_char_p(devs[id]['protocol']) self.mocklib.tdGetModel = lambda id: \ c_char_p(devs[id]['model']) core = TelldusCore() devices = core.devices() self.assertEqual(3, len(devices)) self.assertEqual(['proto_1', 'proto_2', 'proto_3'], [d.protocol for d in devices]) self.assertEqual(['model_1', 'model_2', 'model_3'], [d.model for d in devices])
def run(self): core = TelldusCore() sensorDb = SensorDB(database = 'ha', user = '******', password = '******') while True: listOfSensors = core.sensors() timestamp = 0 for sensor in listOfSensors: if debug: sys.stdout.write("Found sensor: " + str(sensor.id) + "\n") if sensor.has_temperature(): if debug: sys.stdout.write("... sensor supports temperature\n") sensorTemperature = sensor.temperature() timestamp = sensorTemperature.timestamp else: if debug: sys.stdout.write(".. sensor does not support temperature\n") sensorTemperature = SensorValue(const.TELLSTICK_TEMPERATURE, -100.0, 0) if sensor.has_humidity(): if debug: sys.stdout.write("... sensor supports humidity\n") sensorHumidity = sensor.humidity() timestamp = sensorHumidity.timestamp else: if debug: sys.stdout.write(".. sensor does not support humidity\n") sensorHumidity = SensorValue(const.TELLSTICK_HUMIDITY, 0, 0) if timestamp > 0: if sensor.id > 0: sensorDb.insertSensorData(sensor.id, sensorTemperature.value, sensorHumidity.value, timestamp) else: if debug: sys.stdout.write("E: sensor id is not in allowed range\n") else: if debug: sys.stdout.write("Not able to setup timestamp for sensor values\n") if debug: sys.stdout.flush() time.sleep(300)
def command(command,device_id): tlock.acquire(True) core = TelldusCore() if device_id < len(core.devices()): d = core.devices()[device_id] else: return "Unknow id "+str(device_id) if ((command == "E") or (command == "0") or (command == 0) or (command == "OFF") or (command == False)): command = False elif (command == "!") or (command == -1) or (command == "-1"): if d.last_sent_command(tellcore.constants.TELLSTICK_TURNON | tellcore.constants.TELLSTICK_TURNOFF)==tellcore.constants.TELLSTICK_TURNON: command = False else: command = True else: command = True if (not command): d.turn_off() elif (command): d.turn_on() tlock.release() return d.name + " is now " + str(command)
def test_device_event(self): core = TelldusCore() self.event_tester(core, core.register_device_event, self.mockdispatcher.trigger_device_event, (c_int(1), c_int(2), c_char_p(b"foo")))
# -*- coding: utf-8 -*- import sys, os, signal, datetime, threading, logging, time, uuid from flask import Flask, render_template, jsonify, request, url_for from tellcore.telldus import TelldusCore from wit import Wit from os import system sys.path.insert(0, "./modules/") from get_data import RemoteData from audio_handler import AudioHandler from nlg import NLG from cal import Calendar core = TelldusCore() devices = {} for device in core.devices(): devices[device.name] = device devices_in_room = { "bedroom": ["sovrum"], "living room": ["skrivbord"], "office": ["skrivbord"], } device_translation = {"desk lamp": "skrivbord", "bed lamp": "sovrum"} app = Flask(__name__) log = logging.getLogger('werkzeug') log.setLevel(logging.ERROR)
def _getSensors(): tdc = TelldusCore() return tdc.sensors()
blinks = 0 blinks_total = 0 max_temp = 0 min_temp = 0 sensors = {11: Sensor("ute"), 12: Sensor("pumpe"), 21: Sensor("gang"), 22: Sensor("soverom"), 23: Sensor("stue")} app = firebase.FirebaseApplication("https://hytta.firebaseio.com/", None) GPIO.setmode(GPIO.BOARD) GPIO.setup(7, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) GPIO.add_event_detect(7, GPIO.RISING, callback=on_blink, bouncetime=500) td_core = TelldusCore() td_core.register_sensor_event(on_sensor_event) run_daily(update_energy) run_minutely(update_power) run_minutely(td_core.callback_dispatcher.process_pending_callbacks) # def switch2_changed(response): # print(response) # if response == TELLSTICK_TURNON: # camera_switch.turn_on() # print('Switch 2: On') # elif response == TELLSTICK_TURNOFF: # print('Switch 2: Off') # camera_switch.turn_off()
def test_device_change_event(self): core = TelldusCore(callback_dispatcher=QueuedCallbackDispatcher()) self.event_tester(core, core.register_device_change_event, self.mockdispatcher.trigger_device_change_event, (c_int(3), c_int(4), c_int(5)))
from tellcore.telldus import TelldusCore core = TelldusCore() lamp = core.add_device("lamp", "arctech", "selflearning-switch", house=12345, unit=1) lamp.turn_on() for device in core.devices(): device.turn_off()
def activateFan(): core = TelldusCore() for device in core.devices(): if "Fan control device" == device.name: device.turn_on()
def test_raw_device_event(self): core = TelldusCore() self.event_tester(core, core.register_raw_device_event, self.mockdispatcher.trigger_raw_device_event, (c_char_p(b"bar"), c_int(6)))
import time from tellcore.telldus import TelldusCore core = TelldusCore() #Configure reporters from Reporters import EmonCMS_Reporter, Console_Reporter reporter1 = EmonCMS_Reporter("https://emoncms.org", apikey="YOUR_API_KEY", node="MY_NODE_NAME", only_mapped=True) #reporter2 = EmonCMS_Reporter("http://yourserver.me:8080",apikey="YOUR_API_KEY2",node="MY_NODE_NAME2",only_mapped=True) reporter3 = Console_Reporter(only_mapped=False) reporters = [reporter1, reporter3] #How frequently to pull sensor data from Telldus Core (in seconds) reporting_interval = 60 from Sensor_record import Sensor_record stop_time = time.time() while True: start_time = stop_time Sensor_records = map(Sensor_record, core.sensors()) for reporter in reporters: #By first buffering all the sensors and flushing at the end, we will only get one timeout in case the server #is not available. map(reporter.report_async, Sensor_records) reporter.flush_buffer()
print "}" print "</script>" print "<body>" print """<button onclick="goBack()">Go Back</button>""" print "</body>" exit() #end here if errors device_id, power, powerOnTime = int( form['device'].value), form['power'].value, int(form['time'].value) if not ('pass' in form and form['pass'].value == "p@ssw0rd"): print "<p class=errr> Password is incorrect." exit() from tellcore.telldus import TelldusCore core = TelldusCore() devices = core.devices() if not (power in ['off', 'on', 'time'] and device_id <= len(devices)): print "<p class=err> Incorrect values for the params have been provided." print "<script>" print "function goBack()" print "{" print "window.history.back()" print "}" print "</script>" print "<body>" print """<button onclick="goBack()">Go Back</button>""" print "</body>" exit() #end here if errors
def test_sensor_event(self): core = TelldusCore() self.event_tester(core, core.register_sensor_event, self.mockdispatcher.trigger_sensor_event, (c_char_p(b"proto"), c_char_p(b"model"), c_int(7), c_int(8), c_char_p(b"value"), c_int(9)))
def test_controller_event(self): core = TelldusCore() self.event_tester(core, core.register_controller_event, self.mockdispatcher.trigger_controller_event, (c_int(10), c_int(11), c_int(12), c_char_p(b"new")))
try: import asyncio loop = asyncio.get_event_loop() dispatcher = td.AsyncioCallbackDispatcher(loop) except ImportError: loop = None dispatcher = td.QueuedCallbackDispatcher() ip_queue = Queue() ip_queue.put('10.0.0.73') work_queue = Queue() # core = TelldusCore() core = TelldusCore(callback_dispatcher=dispatcher) callbacks = [core.register_raw_device_event(raw_event)] web_thread = threading.Thread(target=run, kwargs={ 'host': '0.0.0.0', 'port': 8888 }) web_thread.daemon = True worker_thread = threading.Thread(target=queue_worker) worker_thread.daemon = True # run(host='0.0.0.0', port=8888) try: web_thread.start()
def test_sensors(self): self.sensor_index = 0 def tdSensor(protocol, p_len, model, m_len, id, datatypes): sensors = [{'protocol': b"proto_1", 'model': b"model_1", 'id': 1, 'datatypes': TELLSTICK_TEMPERATURE}, {'protocol': b"proto_2", 'model': b"model_2", 'id': 2, 'datatypes': TELLSTICK_HUMIDITY}, {'protocol': b"proto_3", 'model': b"model_3", 'id': 3, 'datatypes': TELLSTICK_RAINRATE}, {'protocol': b"proto_4", 'model': b"model_4", 'id': 4, 'datatypes': TELLSTICK_RAINTOTAL}, {'protocol': b"proto_5", 'model': b"model_5", 'id': 5, 'datatypes': TELLSTICK_WINDDIRECTION}, {'protocol': b"proto_6", 'model': b"model_6", 'id': 6, 'datatypes': TELLSTICK_WINDAVERAGE}, {'protocol': b"proto_7", 'model': b"model_7", 'id': 7, 'datatypes': TELLSTICK_WINDGUST}] if self.sensor_index < len(sensors): sensor = sensors[self.sensor_index] self.sensor_index += 1 protocol.value = sensor['protocol'] model.value = sensor['model'] try: id._obj.value = sensor['id'] datatypes._obj.value = sensor['datatypes'] except AttributeError: # With pypy we must use contents instead of _obj id.contents.value = sensor['id'] datatypes.contents.value = sensor['datatypes'] return TELLSTICK_SUCCESS else: self.sensor_index = 0 return TELLSTICK_ERROR_DEVICE_NOT_FOUND self.mocklib.tdSensor = tdSensor def tdSensorValue(protocol, model, id, datatype, value, v_len, times): if datatype == 1 << (id - 1): value.value = self.encode_string("%d" % (id * 100 + datatype)) return TELLSTICK_SUCCESS else: return TELLSTICK_ERROR_METHOD_NOT_SUPPORTED self.mocklib.tdSensorValue = tdSensorValue core = TelldusCore() sensors = core.sensors() self.assertEqual(7, len(sensors)) self.assertEqual(["proto_%d" % i for i in range(1, 8)], [s.protocol for s in sensors]) self.assertEqual(["model_%d" % i for i in range(1, 8)], [s.model for s in sensors]) self.assertEqual(list(range(1, 8)), [s.id for s in sensors]) self.assertEqual([TELLSTICK_TEMPERATURE, TELLSTICK_HUMIDITY, TELLSTICK_RAINRATE, TELLSTICK_RAINTOTAL, TELLSTICK_WINDDIRECTION, TELLSTICK_WINDAVERAGE, TELLSTICK_WINDGUST], [s.datatypes for s in sensors]) self.assertEqual([False] * 0 + [True] + [False] * 6, [s.has_temperature() for s in sensors]) self.assertEqual([False] * 1 + [True] + [False] * 5, [s.has_humidity() for s in sensors]) self.assertEqual([False] * 2 + [True] + [False] * 4, [s.has_rainrate() for s in sensors]) self.assertEqual([False] * 3 + [True] + [False] * 3, [s.has_raintotal() for s in sensors]) self.assertEqual([False] * 4 + [True] + [False] * 2, [s.has_winddirection() for s in sensors]) self.assertEqual([False] * 5 + [True] + [False] * 1, [s.has_windaverage() for s in sensors]) self.assertEqual([False] * 6 + [True] + [False] * 0, [s.has_windgust() for s in sensors]) self.assertEqual("%d" % (100 + TELLSTICK_TEMPERATURE), sensors[0].temperature().value) self.assertEqual("%d" % (200 + TELLSTICK_HUMIDITY), sensors[1].humidity().value) self.assertEqual("%d" % (300 + TELLSTICK_RAINRATE), sensors[2].rainrate().value) self.assertEqual("%d" % (400 + TELLSTICK_RAINTOTAL), sensors[3].raintotal().value) self.assertEqual("%d" % (500 + TELLSTICK_WINDDIRECTION), sensors[4].winddirection().value) self.assertEqual("%d" % (600 + TELLSTICK_WINDAVERAGE), sensors[5].windaverage().value) self.assertEqual("%d" % (700 + TELLSTICK_WINDGUST), sensors[6].windgust().value)
try: import asyncio loop = asyncio.get_event_loop() dispatcher = td.AsyncioCallbackDispatcher(loop) except ImportError: loop = None dispatcher = td.QueuedCallbackDispatcher() ip_queue = Queue() ip_queue.put('10.0.0.73') work_queue = Queue() # core = TelldusCore() core = TelldusCore(callback_dispatcher=dispatcher) callbacks = [core.register_raw_device_event(raw_event)] web_thread = threading.Thread(target=run, kwargs={'host': '0.0.0.0', 'port': 8888}) web_thread.daemon = True worker_thread = threading.Thread(target=queue_worker) worker_thread.daemon = True # run(host='0.0.0.0', port=8888) try: web_thread.start() worker_thread.start() # web_thread.join() # worker_thread.join()
def test_device_change_event(self): core = TelldusCore() self.event_tester(core, core.register_device_change_event, self.mockdispatcher.trigger_device_change_event, (c_int(3), c_int(4), c_int(5)))
elif action == "on": return onaction else: raise IllegalArgumentException() def getshutdown(): def shutdown(): if messagebox.askyesno("Really shut down?", "Are you sure you want to shut down the remote?"): call(["sudo", "poweroff"]) return shutdown tk = Tk() tell = TelldusCore() font = Font(size=16) root = ScrolledWindow(tk, scrollbar=Y) root.vsb.config(width=28) col = 0 row = 0 devices = tell.devices() devices.sort(key=(lambda device: device.name)) for device in devices: container = Frame(root.window) label = Label(container, text=device.name, font=font)
def _getSensors(): tdc = TelldusCore() return tdc.sensors()
import time import os import math import webbrowser from urllib.parse import urlparse import pyautogui as pag from tellcore.telldus import TelldusCore from ctypes import cast, POINTER from comtypes import CLSCTX_ALL from pycaw.pycaw import AudioUtilities, IAudioEndpointVolume from wit_recognition import recognize_cmd core = TelldusCore() lights = core.devices()[1] numbers = { 'zero': 0, 'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'eight': 8, 'nine': 9, 'ten': 10, # 'eleven': 11, }
class TellstickActor(AbstractActor): # Setup def setup(self): # Callback dispatcher # -------------------- # Dispatcher for use with the event loop available in Python 3.4+. # Callbacks will be dispatched on the thread running the event loop. # The loop argument should be a BaseEventLoop instance, e.g. the one # returned from asyncio.get_event_loop(). dispatcher = AsyncioCallbackDispatcher(self.context.loop) # Telldus core # -------------------- # The main class for tellcore-py. Has methods for adding devices and for # enumerating controllers, devices and sensors. Also handles callbacks; # both registration and making sure the callbacks are processed in the # main thread instead of the callback thread. self.telldus = TelldusCore(callback_dispatcher=dispatcher) # Devices # -------------------- # List of configured devices in /etc/tellstick.conf self.devices = self.get_devices() # self.last_seen = {} self.state.devices = {did: d.name for did, d in self.devices.items()} # Register event callback handlers self.telldus.register_device_event(self.callbacks.device_event) self.telldus.register_device_change_event( self.callbacks.device_change_event) self.telldus.register_raw_device_event(self.callbacks.raw_event) # self.telldus.register_sensor_event(self.sensor_event) # self.telldus.register_controller_event(self.controller_event) # Get devices def get_devices(self): ''' Return all known devices. ''' logger.debug('Fetching list of known devices') devices = self.telldus.devices() for d in devices: logger.debug('> Device: {0}, {1}, {2}, {3}, {4}'.format( d.id, d.name, d.protocol, d.type, d.model)) return {device.id: device for device in devices} # Class: Callbacks class Callbacks(AbstractActor.Callbacks): # Device event def device_event(self, device_id, method, data, cid): ''' Device event callback handler. ''' logger.debug( 'Device event, id={}, method={}, data={}, cid={}'.format( device_id, method, data, cid)) method_string = METHODS.get(method) if not method_string: logger.warning('Unknown method %s' % (method)) return # self.actor.last_seen[device_id] = method_string # self.actor.state.last_seen = self.actor.last_seen self.actor.create_event( name='%s.%s' % (method_string, self.actor.devices[device_id].name), payload={ 'method': method_string, 'id': device_id, 'name': self.actor.devices[device_id].name, }) # Device change event def device_change_event(self, id, event, type, cid): ''' Device change event callback handler. ''' event_string = EVENTS.get(event, "UNKNOWN EVENT {0}".format(event)) string = "[DEVICE_CHANGE] {0} {1}".format(event_string, id) if event == const.TELLSTICK_DEVICE_CHANGED: type_string = CHANGES.get(type, "UNKNOWN CHANGE {0}".format(type)) string += " [{0}]".format(type_string) logger.debug(string) print(string) # Raw event def raw_event(self, data, controller_id, cid): ''' Raw device event callback handler. ''' logger.debug('Raw[%s]:%s' % (str(controller_id), data)) ''' def sensor_event(self, protocol, model, id_, dataType, value, timestamp, cid): logger.debug('Sensor event: [SENSOR] {0} [{1}/{2}] ({3}) @ {4} <- {5}'.format( id_, protocol, model, dataType, timestamp, value )) def controller_event(self, id_, event, type_, new_value, cid): event_string = EVENTS.get(event, "UNKNOWN EVENT {0}".format(event)) string = "[CONTROLLER] {0} {1}".format(event_string, id_) if event == const.TELLSTICK_DEVICE_ADDED: type_string = TYPES.get(type_, "UNKNOWN TYPE {0}".format(type_)) string += " {0}".format(type_string) elif (event == const.TELLSTICK_DEVICE_CHANGED or event == const.TELLSTICK_DEVICE_STATE_CHANGED): type_string = CHANGES.get(type_, "UNKNOWN CHANGE {0}".format(type_)) string += " [{0}] -> {1}".format(type_string, new_value) print(string) ''' # Class: Actions class Actions(AbstractActor.Actions): def on(self, device_id): device = self.actor.devices.get(device_id) if not device: return False, 'Unknown device' device.turn_on() return True, 'Device "%s" turned on' % (device.name) def off(self, device_id): device = self.actor.devices.get(device_id) if not device: return False, 'Unknown device' device.turn_off() return True, 'Device "%s" turned off' % (device.name) def dim(self, device_id, level=50): if level < 0 or level > 255: return False, 'Invalid dim level (%s)' % (str(level)) device = self.actor.devices.get(device_id) if not device: return False, 'Unknown device' device.dim(level) return True, 'Device "%s" dimmed to level %d' % (device.name, level) def all_on(self, exclude=[]): for device in self.actor.devices.values(): if device.id not in exclude: device.turn_on() return True, 'All devices (%d) turned on' % (len( self.actor.devices)) def all_off(self, exclude=[]): for device in self.actor.devices.values(): if device.id not in exclude: device.turn_on() return True, 'All devices (%d) turned off' % (len( self.actor.devices))
def setup(hass, config): """Set up the Tellstick component.""" from tellcore.constants import TELLSTICK_DIM from tellcore.telldus import AsyncioCallbackDispatcher from tellcore.telldus import TelldusCore from tellcorenet import TellCoreClient conf = config.get(DOMAIN, {}) net_host = conf.get(CONF_HOST) net_port = conf.get(CONF_PORT) # Initialize remote tellcore client if net_host and net_port: net_client = TellCoreClient(net_host, net_port) net_client.start() def stop_tellcore_net(event): """Event handler to stop the client.""" net_client.stop() hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, stop_tellcore_net) try: tellcore_lib = TelldusCore( callback_dispatcher=AsyncioCallbackDispatcher(hass.loop)) except OSError: _LOGGER.exception("Could not initialize Tellstick") return False # Get all devices, switches and lights alike tellcore_devices = tellcore_lib.devices() # Register devices hass.data[DATA_TELLSTICK] = {device.id: device for device in tellcore_devices} # Discover the switches _discover(hass, config, 'switch', [device.id for device in tellcore_devices if not device.methods(TELLSTICK_DIM)]) # Discover the lights _discover(hass, config, 'light', [device.id for device in tellcore_devices if device.methods(TELLSTICK_DIM)]) @callback def async_handle_callback(tellcore_id, tellcore_command, tellcore_data, cid): """Handle the actual callback from Tellcore.""" hass.helpers.dispatcher.async_dispatcher_send( SIGNAL_TELLCORE_CALLBACK, tellcore_id, tellcore_command, tellcore_data) # Register callback callback_id = tellcore_lib.register_device_event( async_handle_callback) def clean_up_callback(event): """Unregister the callback bindings.""" if callback_id is not None: tellcore_lib.unregister_callback(callback_id) hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, clean_up_callback) return True
# Getting the token from command-line is better than embedding it in code, # because tokens are supposed to be kept secret. TOKEN = sys.argv[1] user_ids = [] user_state = [] for index in range(2, len(sys.argv)): user_ids.append(long(sys.argv[index])) user_state.append(DF_DEFAULT) localtime = time.asctime( time.localtime(time.time()) ) print "Local current time :", localtime print 'Init telldus core' lightcore = TelldusCore() light_list = [] names = [] groups = [] # Parse from XML xml_config = untangle.parse('config.xml') for switch in xml_config.control.devices.switch: names.append(switch['name']) light_list.append(lightcore.add_device( switch['name'], switch['protocol'], switch['model'], house=switch['house'], unit=switch['unit'], code=switch['code']))
def setup(opp, config): """Set up the Tellstick component.""" conf = config.get(DOMAIN, {}) net_host = conf.get(CONF_HOST) net_ports = conf.get(CONF_PORT) # Initialize remote tellcore client if net_host: net_client = TellCoreClient(host=net_host, port_client=net_ports[0], port_events=net_ports[1]) net_client.start() def stop_tellcore_net(event): """Event handler to stop the client.""" net_client.stop() opp.bus.listen_once(EVENT_OPENPEERPOWER_STOP, stop_tellcore_net) try: tellcore_lib = TelldusCore( callback_dispatcher=AsyncioCallbackDispatcher(opp.loop)) except OSError: _LOGGER.exception("Could not initialize Tellstick") return False # Get all devices, switches and lights alike tellcore_devices = tellcore_lib.devices() # Register devices opp.data[DATA_TELLSTICK] = { device.id: device for device in tellcore_devices } # Discover the lights _discover( opp, config, "light", [ device.id for device in tellcore_devices if device.methods(TELLSTICK_DIM) ], ) # Discover the cover _discover( opp, config, "cover", [ device.id for device in tellcore_devices if device.methods(TELLSTICK_UP) ], ) # Discover the switches _discover( opp, config, "switch", [ device.id for device in tellcore_devices if (not device.methods(TELLSTICK_UP) and not device.methods(TELLSTICK_DIM)) ], ) @callback def async_handle_callback(tellcore_id, tellcore_command, tellcore_data, cid): """Handle the actual callback from Tellcore.""" opp.helpers.dispatcher.async_dispatcher_send(SIGNAL_TELLCORE_CALLBACK, tellcore_id, tellcore_command, tellcore_data) # Register callback callback_id = tellcore_lib.register_device_event(async_handle_callback) def clean_up_callback(event): """Unregister the callback bindings.""" if callback_id is not None: tellcore_lib.unregister_callback(callback_id) opp.bus.listen_once(EVENT_OPENPEERPOWER_STOP, clean_up_callback) return True
import sqlite3 import datetime import time from tellcore.telldus import TelldusCore from enum import Enum BEDROOM = 151 BALCONY = 135 KTICHEN = 167 offset_bedroom = 0.5 core = TelldusCore() conn = sqlite3.connect( '/home/pi/projects/sensor_webbapp/sensor_reading/sensordata.db') curs = conn.cursor() while (True): try: list_sensors = core.sensors() print(len(list_sensors)) if list_sensors is not None: for sens in list_sensors: dev_id = sens.id temp = sens.value(1).value hum = sens.value(2).value if dev_id == BEDROOM: curs.execute( "INSERT INTO sensor_data VALUES (datetime('now'), ?, ?,?)", (float(temp) + offset_bedroom, hum, dev_id)) print( "Added reading for bedroom, dev_id: {} temp: {}, hum: {}"