def setup(hass, config): """Setup the Homematic component.""" global HOMEMATIC, HOMEMATIC_LINK_DELAY from pyhomematic import HMConnection local_ip = config[DOMAIN][0].get(CONF_LOCAL_IP) local_port = config[DOMAIN][0].get(CONF_LOCAL_PORT) remote_ip = config[DOMAIN][0].get(CONF_REMOTE_IP) remote_port = config[DOMAIN][0].get(CONF_REMOTE_PORT) resolvenames = config[DOMAIN][0].get(CONF_RESOLVENAMES) username = config[DOMAIN][0].get(CONF_USERNAME) password = config[DOMAIN][0].get(CONF_PASSWORD) HOMEMATIC_LINK_DELAY = config[DOMAIN][0].get(CONF_DELAY) if remote_ip is None or local_ip is None: _LOGGER.error("Missing remote CCU/Homegear or local address") return False # Create server thread bound_system_callback = partial(system_callback_handler, hass, config) HOMEMATIC = HMConnection(local=local_ip, localport=local_port, remote=remote_ip, remoteport=remote_port, systemcallback=bound_system_callback, resolvenames=resolvenames, rpcusername=username, rpcpassword=password, interface_id="homeassistant") # Start server thread, connect to peer, initialize to receive events HOMEMATIC.start() # Stops server when Homeassistant is shutting down hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, HOMEMATIC.stop) hass.config.components.append(DOMAIN) # regeister homematic services descriptions = load_yaml_config_file( os.path.join(os.path.dirname(__file__), 'services.yaml')) hass.services.register(DOMAIN, SERVICE_VIRTUALKEY, _hm_service_virtualkey, descriptions[DOMAIN][SERVICE_VIRTUALKEY], SCHEMA_SERVICE_VIRTUALKEY) return True
class Test_2_PyhomematicDevices(unittest.TestCase): def setUp(self): LOG.debug("TestPyhomematicDevices.setUp") s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(("", 0)) self.localport = s.getsockname()[1] s.close() self.vccu = vccu.ServerThread(local=DEFAULT_IP, localport=self.localport) self.vccu.start() time.sleep(0.5) self.client = HMConnection(interface_id=DEFAULT_INTERFACE_CLIENT, autostart=False, remotes={ DEFAULT_REMOTE: { "ip": DEFAULT_IP, "port": self.localport, "connect": True } }) self.client.start() time.sleep(STARTUP_DELAY) def tearDown(self): LOG.debug("TestPyhomematicDevices.tearDown") self.client.stop() self.vccu.stop() def test_0_pyhomematic_classes(self): LOG.info("TestPyhomematicDevices.test_0_pyhomematic_classes") devices = self.client.devices.get(DEFAULT_REMOTE) for _, deviceobject in devices.items(): deviceclass = devicetypes.SUPPORTED.get(deviceobject.TYPE, None) devicedata = DEVICES.get(deviceobject.TYPE, {}) if deviceclass: self.assertIsInstance(deviceobject, deviceclass) else: if not devicedata.get("supported", True): LOG.info("Unsupported device: %s" % deviceobject.TYPE) else: LOG.warning("Device class missing for: %s" % deviceobject.TYPE)
def setUp(self): LOG.debug("TestPyhomematicDevices.setUp") s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(("", 0)) self.localport = s.getsockname()[1] s.close() self.vccu = vccu.ServerThread(local=DEFAULT_IP, localport=self.localport) self.vccu.start() time.sleep(0.5) self.client = HMConnection(interface_id=DEFAULT_INTERFACE_CLIENT, autostart=False, remotes={ DEFAULT_REMOTE: { "ip": DEFAULT_IP, "port": self.localport, "connect": True } }) self.client.start() time.sleep(STARTUP_DELAY)
def setup(hass, config): """Setup the Homematic component.""" global HOMEMATIC, HOMEMATIC_LINK_DELAY from pyhomematic import HMConnection local_ip = config[DOMAIN].get("local_ip", None) local_port = config[DOMAIN].get("local_port", 8943) remote_ip = config[DOMAIN].get("remote_ip", None) remote_port = config[DOMAIN].get("remote_port", 2001) resolvenames = config[DOMAIN].get("resolvenames", False) username = config[DOMAIN].get("username", "Admin") password = config[DOMAIN].get("password", "") HOMEMATIC_LINK_DELAY = config[DOMAIN].get("delay", 0.5) if remote_ip is None or local_ip is None: _LOGGER.error("Missing remote CCU/Homegear or local address") return False # Create server thread bound_system_callback = partial(system_callback_handler, hass, config) HOMEMATIC = HMConnection(local=local_ip, localport=local_port, remote=remote_ip, remoteport=remote_port, systemcallback=bound_system_callback, resolvenames=resolvenames, rpcusername=username, rpcpassword=password, interface_id="homeassistant") # Start server thread, connect to peer, initialize to receive events HOMEMATIC.start() # Stops server when Homeassistant is shutting down hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, HOMEMATIC.stop) hass.config.components.append(DOMAIN) return True
def run(self, listen: str, connect: str) -> None: try: xmlrpc_local = self._xmlrpc_listen_url(listen) xmlrpc_remote = self._xmlrpc_connect_url(connect) except ValueError as exc: logger.error("Invalid XML-RPC URL: %s", exc) sys.exit(1) homematic = HMConnection( interface_id="inventory", local=xmlrpc_local.hostname, localport=xmlrpc_local.port or 0, remotes={ "default": { "ip": xmlrpc_remote.hostname, "port": xmlrpc_remote.port, "path": xmlrpc_remote.path or "", "username": xmlrpc_remote.username or "Admin", "password": xmlrpc_remote.password or "", } }, eventcallback=self._event_callback, systemcallback=self._system_callback, ) try: homematic.start() except AttributeError: sys.exit(1) def handler(signum, frame): signal(signum, SIG_DFL) homematic.stop() for signum in (SIGINT, SIGTERM): signal(signum, handler) homematic._server.join()
def test_0_pyhomematic_noinit(self): LOG.info("TestPyhomematicBase.test_0_pyhomematic_noinit") client = HMConnection(interface_id=DEFAULT_INTERFACE_CLIENT, autostart=False, remotes={ DEFAULT_REMOTE: { "ip": DEFAULT_IP, "port": self.localport, "connect": False } }) client.start() time.sleep(STARTUP_DELAY) servicemessages = client.getServiceMessages(DEFAULT_REMOTE) self.assertEqual(len(servicemessages), 1) self.assertEqual(servicemessages[0][0], 'VCU0000001:1') client.stop()
async def run(self, broker: str, listen: str, connect: str) -> None: p = urlparse(broker, scheme="mqtt") if p.scheme not in ("mqtt", "mqtts") or not p.hostname: raise ValueError tls_context = None if p.scheme == "mqtts": tls_context = ssl.create_default_context() will = None async with Client( p.hostname, port=p.port or p.scheme == "mqtt" and 1883 or 8883, username=p.username, password=p.password, logger=logger, tls_context=tls_context, will=will, ) as mqtt: xmlrpc_local = self._xmlrpc_listen_url(listen) xmlrpc_remote = self._xmlrpc_connect_url(connect) homematic = HMConnection( interface_id=HM_INTERFACE_ID, local=xmlrpc_local.hostname, localport=xmlrpc_local.port or 0, remotes={ HM_REMOTE: { "ip": xmlrpc_remote.hostname, "port": xmlrpc_remote.port, "path": xmlrpc_remote.path or "", "username": xmlrpc_remote.username or "Admin", "password": xmlrpc_remote.password or "", } }, eventcallback=partial(self._event_callback, mqtt), systemcallback=partial(self._system_callback, mqtt), ) try: homematic.start() except AttributeError: sys.exit(1) async with mqtt.unfiltered_messages() as messages: async for message in messages: await self._process_packet(message, homematic) homematic.stop()
def test_1_pyhomematic_init(self): LOG.info("TestPyhomematicBase.test_1_pyhomematic_init") client = HMConnection(interface_id=DEFAULT_INTERFACE_CLIENT, autostart=False, remotes={ DEFAULT_REMOTE: { "ip": DEFAULT_IP, "port": self.localport, "connect": True } }) client.start() time.sleep(STARTUP_DELAY) servicemessages = client.getServiceMessages(DEFAULT_REMOTE) self.assertEqual(len(servicemessages), 1) self.assertEqual(servicemessages[0][0], 'VCU0000001:1') self.assertIsInstance(client.devices, dict) devices = client.devices.get(DEFAULT_REMOTE) self.assertIsInstance(devices, dict) self.assertGreater(len(devices.keys()), 0) client.stop()
DEVICE2 = 'address_of_doorcontact' # e.g. LEQ1234567 DEVICE3 = 'address_of_thermostat' def systemcallback(src, *args): print(src) for arg in args: print(arg) try: # Create a server that listens on 127.0.0.1:7080 and identifies itself as myserver. # Connect to Homegear at 127.0.0.1:2001 # Automatically start everything. Without autostart, pyhomematic.start() can be called. # We add a systemcallback so we can see what else happens besides the regular events. pyhomematic = HMConnection(interface_id="myserver", autostart=True, systemcallback=systemcallback, remotes={"rf":{ "ip":"127.0.0.1", "port": 2001}}) except Exception: sys.exit(1) sleepcounter = 0 def eventcallback(address, interface_id, key, value): print("CALLBACK: %s, %s, %s, %s" % (address, interface_id, key, value)) while not pyhomematic.devices and sleepcounter < 20: print("Waiting for devices") sleepcounter += 1 time.sleep(1) print(pyhomematic.devices)
def cli(local, localport, remote, remoteport, address, channel, state, toggle, timer, debug, user, password, variable, data): # debug? if debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.INFO) try: # Connect to HM pyhomematic = HMConnection(interface_id="test-pyhomatic", local=local, localport=localport, remote=remote, remoteport=remoteport, autostart=True, rpcusername=user, rpcpassword=password, systemcallback=systemcallback) except: print("Can't init HMConnection!") sys.exit(1) sleepcounter = 0 while not pyhomematic.devices and sleepcounter < 20: print("Waiting for devices") sleepcounter += 1 time.sleep(1) print(pyhomematic.devices) # read system variables print("******************************") print("Read all: %s" % str(pyhomematic.getAllSystemVariables())) if variable is not None: pyhomematic.setSystemVariable(variable, data) print("Read: %s" % str(pyhomematic.getSystemVariable(variable))) print("******************************") # need test a hm object? if address in pyhomematic.devices: device = pyhomematic.devices[address] print("******************************") print("* Show metadata from %s" % address) print("* Elements: %s / Childs: %i" % (device.ELEMENT, len(device.CHANNELS))) print("* Class: %s" % str(device.__class__)) print("* Base: %s" % str(device.__class__.__bases__)) print("* Sensor datapoint: %s" % str(device.SENSORNODE)) print("* Binary datapoint: %s" % str(device.BINARYNODE)) print("* Write datapoint: %s" % str(device.WRITENODE)) print("* Attribute datapoint: %s" % str(device.ATTRIBUTENODE)) print("* Event datapoint: %s" % str(device.EVENTNODE)) print("* Action datapoint: %s" % str(device.ACTIONNODE)) print("******************************") # WeatherSensor if isinstance(device, WeatherSensor): print(" / Temperature: %f" % device.get_temperature()) print(" / Humidity: %i" % device.get_humidity()) print(" / Rain Counter: %f" % device.get_rain_counter()) print(" / Wind Speed: %f" % device.get_wind_speed()) print(" / Wind Direction: %i" % device.get_wind_direction()) print(" / Wind Direction Range: %i" % device.get_wind_direction_range()) print(" / Sunshineduration: %i" % device.get_sunshineduration()) print(" / Brightness: %i" % device.get_brightness()) print(" / Is Raining: %s" % str(device.is_raining())) # AreaThermostat if isinstance(device, AreaThermostat): print(" / Temperature: %f" % device.get_temperature()) print(" / Humidity: %i" % device.get_humidity()) # ShutterContact if isinstance(device, ShutterContact): print(" / Contact open: %s" % str(device.is_open())) # Smoke if isinstance(device, Smoke): print(" / Smoke detect: %s" % str(device.is_smoke())) # Motion if isinstance(device, Motion): print(" / Motion detect: %s" % str(device.is_motion())) print(" / Brightness: %i" % device.get_brightness()) # Remote if isinstance(device, Remote): print(" / is a Remote") if toggle: print(" / Press short/long") device.press_long(channel) device.press_short(channel) # Switch if isinstance(device, GenericSwitch): print(" / Switch is on: %s" % str(device.is_on(channel))) if toggle: print(" / Changee state to: %s" % str(bool(state))) device.set_state(bool(state), channel) print(" / Switch is on: %s" % str(device.is_on(channel))) ########### Attribute ######### print(" / RSSI_DEVICE: %i" % device.get_rssi()) if isinstance(device, HelperLowBat): print(" / Low batter: %s" % str(device.low_batt())) if isinstance(device, HelperSabotage): print(" / Sabotage: %s" % str(device.sabotage())) if isinstance(device, HelperWorking): print(" / Working: %s" % str(device.is_working())) if isinstance(device, HelperValveState): print(" / Valve state: %i" % device.valve_state()) if isinstance(device, HelperBatteryState): print(" / Bettery state: %f" % device.battery_state()) # do nothing for show & debug events print("Now waiting for events/callback") time.sleep(timer) # end pyhomematic.stop()
def cli(local, localport, remote, remoteport, address, channel, state, toggle, timer, debug, user, password, variable, data): # debug? if debug: logging.basicConfig(level=logging.DEBUG) else: logging.basicConfig(level=logging.INFO) try: # Connect to HM pyhomematic = HMConnection(interface_id="testpyhomatic", local=local, localport=localport, remote=remote, remoteport=remoteport, autostart=True, rpcusername=user, rpcpassword=password, systemcallback=systemcallback) except Exception: print("Can't init HMConnection!") sys.exit(1) sleepcounter = 0 while not pyhomematic.devices and sleepcounter < 20: print("Waiting for devices") sleepcounter += 1 time.sleep(1) print(pyhomematic.devices) # read system variables print("******************************") print("Read all: %s" % str(pyhomematic.getAllSystemVariables('default'))) if variable is not None: pyhomematic.setSystemVariable(variable, data) print("Read: %s" % str(pyhomematic.getSystemVariable(variable))) print("******************************") # need test a hm object? if address in pyhomematic.devices: device = pyhomematic.devices[address] print("******************************") print("* Show metadata from %s" % address) print("* Elements: %s / Childs: %i" % (device.ELEMENT, len(device.CHANNELS))) print("* Class: %s" % str(device.__class__)) print("* Base: %s" % str(device.__class__.__bases__)) print("* Sensor datapoint: %s" % str(device.SENSORNODE)) print("* Binary datapoint: %s" % str(device.BINARYNODE)) print("* Write datapoint: %s" % str(device.WRITENODE)) print("* Attribute datapoint: %s" % str(device.ATTRIBUTENODE)) print("* Event datapoint: %s" % str(device.EVENTNODE)) print("* Action datapoint: %s" % str(device.ACTIONNODE)) print("******************************") # WeatherSensor if isinstance(device, WeatherSensor): print(" / Temperature: %f" % device.get_temperature()) print(" / Humidity: %i" % device.get_humidity()) print(" / Rain Counter: %f" % device.get_rain_counter()) print(" / Wind Speed: %f" % device.get_wind_speed()) print(" / Wind Direction: %i" % device.get_wind_direction()) print(" / Wind Direction Range: %i" % device.get_wind_direction_range()) print(" / Sunshineduration: %i" % device.get_sunshineduration()) print(" / Brightness: %i" % device.get_brightness()) print(" / Is Raining: %s" % str(device.is_raining())) # AreaThermostat if isinstance(device, AreaThermostat): print(" / Temperature: %f" % device.get_temperature()) print(" / Humidity: %i" % device.get_humidity()) # ShutterContact if isinstance(device, ShutterContact): print(" / Contact open: %s" % str(device.is_open())) # Smoke if isinstance(device, Smoke): print(" / Smoke detect: %s" % str(device.is_smoke())) # Motion if isinstance(device, Motion): print(" / Motion detect: %s" % str(device.is_motion())) print(" / Brightness: %i" % device.get_brightness()) # Remote if isinstance(device, Remote): print(" / is a Remote") if toggle: print(" / Press short/long") device.press_long(channel) device.press_short(channel) # Switch if isinstance(device, GenericSwitch): print(" / Switch is on: %s" % str(device.is_on(channel))) if toggle: print(" / Changee state to: %s" % str(bool(state))) device.set_state(bool(state), channel) print(" / Switch is on: %s" % str(device.is_on(channel))) ########### Attribute ######### print(" / RSSI_DEVICE: %i" % device.get_rssi()) if isinstance(device, HelperLowBat): print(" / Low batter: %s" % str(device.low_batt())) if isinstance(device, HelperSabotage): print(" / Sabotage: %s" % str(device.sabotage())) if isinstance(device, HelperWorking): print(" / Working: %s" % str(device.is_working())) if isinstance(device, HelperValveState): print(" / Valve state: %i" % device.valve_state()) if isinstance(device, HelperBatteryState): print(" / Bettery state: %f" % device.battery_state()) # do nothing for show & debug events print("Now waiting for events/callback") time.sleep(timer) # end pyhomematic.stop()
DEVICE3 = 'address_of_thermostat' def systemcallback(src, *args): print(src) for arg in args: print(arg) try: # Create a server that listens on 127.0.0.1:7080 and identifies itself as myserver. # Connect to Homegear at 127.0.0.1:2001 # Automatically start everything. Without autostart, pyhomematic.start() can be called. # We add a systemcallback so we can see what else happens besides the regular events. pyhomematic = HMConnection(interface_id="myserver", local="127.0.0.1", localport=7080, remote="127.0.0.1", remoteport=2001, autostart=True, systemcallback=systemcallback) except: sys.exit(1) sleepcounter = 0 def eventcallback(address, interface_id, key, value): print("CALLBACK: %s, %s, %s, %s" % (address, interface_id, key, value)) while not pyhomematic.devices and sleepcounter < 20: print("Waiting for devices") sleepcounter += 1 time.sleep(1)
def setup(hass, config): """Setup the Homematic component.""" global HOMEMATIC, HOMEMATIC_LINK_DELAY from pyhomematic import HMConnection component = EntityComponent(_LOGGER, DOMAIN, hass) local_ip = config[DOMAIN].get(CONF_LOCAL_IP) local_port = config[DOMAIN].get(CONF_LOCAL_PORT) remote_ip = config[DOMAIN].get(CONF_REMOTE_IP) remote_port = config[DOMAIN].get(CONF_REMOTE_PORT) resolvenames = config[DOMAIN].get(CONF_RESOLVENAMES) username = config[DOMAIN].get(CONF_USERNAME) password = config[DOMAIN].get(CONF_PASSWORD) HOMEMATIC_LINK_DELAY = config[DOMAIN].get(CONF_DELAY) use_variables = config[DOMAIN].get(CONF_VARIABLES) if remote_ip is None or local_ip is None: _LOGGER.error("Missing remote CCU/Homegear or local address") return False # Create server thread bound_system_callback = partial(_system_callback_handler, hass, config) HOMEMATIC = HMConnection(local=local_ip, localport=local_port, remote=remote_ip, remoteport=remote_port, systemcallback=bound_system_callback, resolvenames=resolvenames, rpcusername=username, rpcpassword=password, interface_id="homeassistant") # Start server thread, connect to peer, initialize to receive events HOMEMATIC.start() # Stops server when Homeassistant is shutting down hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, HOMEMATIC.stop) hass.config.components.append(DOMAIN) # regeister homematic services descriptions = load_yaml_config_file( os.path.join(os.path.dirname(__file__), 'services.yaml')) hass.services.register(DOMAIN, SERVICE_VIRTUALKEY, _hm_service_virtualkey, descriptions[DOMAIN][SERVICE_VIRTUALKEY], schema=SCHEMA_SERVICE_VIRTUALKEY) entities = [] ## # init HM variable variables = HOMEMATIC.getAllSystemVariables() if use_variables else {} hm_var_store = {} if variables is not None: for key, value in variables.items(): varia = HMVariable(key, value) hm_var_store.update({key: varia}) entities.append(varia) # add homematic entites entities.append(HMHub(hm_var_store, use_variables)) component.add_entities(entities) ## # register set_value service if exists variables if not variables: return True def _service_handle_value(service): """Set value on homematic variable object.""" variable_list = component.extract_from_service(service) value = service.data[ATTR_VALUE] for hm_variable in variable_list: hm_variable.hm_set(value) hass.services.register(DOMAIN, SERVICE_SET_VALUE, _service_handle_value, descriptions[DOMAIN][SERVICE_SET_VALUE], schema=SCHEMA_SERVICE_SET_VALUE) return True
def setup(hass, config): """Set up the Homematic component.""" from pyhomematic import HMConnection hass.data[DATA_DELAY] = config[DOMAIN].get(CONF_DELAY) hass.data[DATA_DEVINIT] = {} hass.data[DATA_STORE] = set() # Create hosts-dictionary for pyhomematic remotes = {} hosts = {} for rname, rconfig in config[DOMAIN][CONF_HOSTS].items(): server = rconfig.get(CONF_IP) remotes[rname] = {} remotes[rname][CONF_IP] = server remotes[rname][CONF_PORT] = rconfig.get(CONF_PORT) remotes[rname][CONF_RESOLVENAMES] = rconfig.get(CONF_RESOLVENAMES) remotes[rname][CONF_USERNAME] = rconfig.get(CONF_USERNAME) remotes[rname][CONF_PASSWORD] = rconfig.get(CONF_PASSWORD) remotes[rname]['callbackip'] = rconfig.get(CONF_CALLBACK_IP) remotes[rname]['callbackport'] = rconfig.get(CONF_CALLBACK_PORT) if server not in hosts or rconfig.get(CONF_PRIMARY): hosts[server] = { CONF_VARIABLES: rconfig.get(CONF_VARIABLES), CONF_NAME: rname, } hass.data[DATA_DEVINIT][rname] = rconfig.get(CONF_DEVICES) # Create server thread bound_system_callback = partial(_system_callback_handler, hass, config) hass.data[DATA_HOMEMATIC] = HMConnection( local=config[DOMAIN].get(CONF_LOCAL_IP), localport=config[DOMAIN].get(CONF_LOCAL_PORT), remotes=remotes, systemcallback=bound_system_callback, interface_id='homeassistant' ) # Start server thread, connect to hosts, initialize to receive events hass.data[DATA_HOMEMATIC].start() # Stops server when HASS is shutting down hass.bus.listen_once( EVENT_HOMEASSISTANT_STOP, hass.data[DATA_HOMEMATIC].stop) # Init homematic hubs entity_hubs = [] for _, hub_data in hosts.items(): entity_hubs.append(HMHub( hass, hub_data[CONF_NAME], hub_data[CONF_VARIABLES])) # Register HomeMatic services descriptions = load_yaml_config_file( os.path.join(os.path.dirname(__file__), 'services.yaml')) def _hm_service_virtualkey(service): """Service to handle virtualkey servicecalls.""" address = service.data.get(ATTR_ADDRESS) channel = service.data.get(ATTR_CHANNEL) param = service.data.get(ATTR_PARAM) # Device not found hmdevice = _device_from_servicecall(hass, service) if hmdevice is None: _LOGGER.error("%s not found for service virtualkey!", address) return # Parameter doesn't exist for device if param not in hmdevice.ACTIONNODE: _LOGGER.error("%s not datapoint in hm device %s", param, address) return # Channel doesn't exist for device if channel not in hmdevice.ACTIONNODE[param]: _LOGGER.error("%i is not a channel in hm device %s", channel, address) return # Call parameter hmdevice.actionNodeData(param, True, channel) hass.services.register( DOMAIN, SERVICE_VIRTUALKEY, _hm_service_virtualkey, descriptions[DOMAIN][SERVICE_VIRTUALKEY], schema=SCHEMA_SERVICE_VIRTUALKEY) def _service_handle_value(service): """Service to call setValue method for HomeMatic system variable.""" entity_ids = service.data.get(ATTR_ENTITY_ID) name = service.data[ATTR_NAME] value = service.data[ATTR_VALUE] if entity_ids: entities = [entity for entity in entity_hubs if entity.entity_id in entity_ids] else: entities = entity_hubs if not entities: _LOGGER.error("No HomeMatic hubs available") return for hub in entities: hub.hm_set_variable(name, value) hass.services.register( DOMAIN, SERVICE_SET_VAR_VALUE, _service_handle_value, descriptions[DOMAIN][SERVICE_SET_VAR_VALUE], schema=SCHEMA_SERVICE_SET_VAR_VALUE) def _service_handle_reconnect(service): """Service to reconnect all HomeMatic hubs.""" hass.data[DATA_HOMEMATIC].reconnect() hass.services.register( DOMAIN, SERVICE_RECONNECT, _service_handle_reconnect, descriptions[DOMAIN][SERVICE_RECONNECT], schema=SCHEMA_SERVICE_RECONNECT) def _service_handle_device(service): """Service to call setValue method for HomeMatic devices.""" address = service.data.get(ATTR_ADDRESS) channel = service.data.get(ATTR_CHANNEL) param = service.data.get(ATTR_PARAM) value = service.data.get(ATTR_VALUE) # Device not found hmdevice = _device_from_servicecall(hass, service) if hmdevice is None: _LOGGER.error("%s not found!", address) return hmdevice.setValue(param, value, channel) hass.services.register( DOMAIN, SERVICE_SET_DEV_VALUE, _service_handle_device, descriptions[DOMAIN][SERVICE_SET_DEV_VALUE], schema=SCHEMA_SERVICE_SET_DEV_VALUE) return True
def setup(hass, config): """Setup the Homematic component.""" global HOMEMATIC, HOMEMATIC_LINK_DELAY from pyhomematic import HMConnection component = EntityComponent(_LOGGER, DOMAIN, hass) local_ip = config[DOMAIN].get(CONF_LOCAL_IP) local_port = config[DOMAIN].get(CONF_LOCAL_PORT) remote_ip = config[DOMAIN].get(CONF_REMOTE_IP) remote_port = config[DOMAIN].get(CONF_REMOTE_PORT) resolvenames = config[DOMAIN].get(CONF_RESOLVENAMES) username = config[DOMAIN].get(CONF_USERNAME) password = config[DOMAIN].get(CONF_PASSWORD) HOMEMATIC_LINK_DELAY = config[DOMAIN].get(CONF_DELAY) if remote_ip is None or local_ip is None: _LOGGER.error("Missing remote CCU/Homegear or local address") return False # Create server thread bound_system_callback = partial(_system_callback_handler, hass, config) HOMEMATIC = HMConnection(local=local_ip, localport=local_port, remote=remote_ip, remoteport=remote_port, systemcallback=bound_system_callback, resolvenames=resolvenames, rpcusername=username, rpcpassword=password, interface_id="homeassistant") # Start server thread, connect to peer, initialize to receive events HOMEMATIC.start() # Stops server when Homeassistant is shutting down hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, HOMEMATIC.stop) hass.config.components.append(DOMAIN) # regeister homematic services descriptions = load_yaml_config_file( os.path.join(os.path.dirname(__file__), 'services.yaml')) hass.services.register(DOMAIN, SERVICE_VIRTUALKEY, _hm_service_virtualkey, descriptions[DOMAIN][SERVICE_VIRTUALKEY], schema=SCHEMA_SERVICE_VIRTUALKEY) entities = [] ## # init HM variable variables = HOMEMATIC.getAllSystemVariables() if variables is not None: for key, value in variables.items(): entities.append(HMVariable(key, value)) # add homematic entites entities.append(HMHub()) component.add_entities(entities) ## # register set_value service if exists variables if not variables: return True def _service_handle_value(service): """Set value on homematic variable object.""" variable_list = component.extract_from_service(service) value = service.data[ATTR_VALUE] for hm_variable in variable_list: hm_variable.hm_set(value) hass.services.register(DOMAIN, SERVICE_SET_VALUE, _service_handle_value, descriptions[DOMAIN][SERVICE_SET_VALUE], schema=SCHEMA_SERVICE_SET_VALUE) return True
class Homematic(SmartPlugin): """ Main class of the Plugin. Does all plugin specific stuff and provides the update functions for the items """ PLUGIN_VERSION = '1.5.0' # ALLOW_MULTIINSTANCE = False connected = False def __init__(self, sh, *args, **kwargs): """ Initalizes the plugin. The parameters descriptions for this method are pulled from the entry in plugin.yaml. :param sh: **Deprecated**: The instance of the smarthome object. For SmartHomeNG versions **beyond** 1.3: **Don't use it**! :param *args: **Deprecated**: Old way of passing parameter values. For SmartHomeNG versions **beyond** 1.3: **Don't use it**! :param **kwargs:**Deprecated**: Old way of passing parameter values. For SmartHomeNG versions **beyond** 1.3: **Don't use it**! If you need the sh object at all, use the method self.get_sh() to get it. There should be almost no need for a reference to the sh object any more. The parameters *args and **kwargs are the old way of passing parameters. They are deprecated. They are imlemented to support older plugins. Plugins for SmartHomeNG v1.4 and beyond should use the new way of getting parameter values: use the SmartPlugin method get_parameter_value(parameter_name) instead. Anywhere within the Plugin you can get the configured (and checked) value for a parameter by calling self.get_parameter_value(parameter_name). It returns the value in the datatype that is defined in the metadata. """ self.logger = logging.getLogger(__name__) # get the parameters for the plugin (as defined in metadata plugin.yaml): # self.param1 = self.get_parameter_value('param1') # Initialization code goes here self.username = self.get_parameter_value('username') self.password = self.get_parameter_value('password') self.host = self.get_parameter_value('host') # self.port = self.get_parameter_value('port') # self.port_hmip = self.get_parameter_value('port_hmip') self.port = 2001 self.port_hmip = 2010 # build dict identifier for the homematic ccu of this plugin instance self.hm_id = 'rf' if self.get_instance_name() != '': self.hm_id += '_' + self.get_instance_name() self.log_instance_str = ' ('+self.get_instance_name()+')' else: self.log_instance_str = '' # create HomeMatic object try: self.hm = HMConnection(interface_id="myserver", autostart=False, eventcallback=self.eventcallback, systemcallback=self.systemcallback, remotes={self.hm_id:{"ip": self.host, "port": self.port}}) # remotes={self.hm_id:{"ip": self.host, "port": self.port}, self.hmip_id:{"ip": self.host, "port": self.port_hmip}}) except: self.logger.error("{}: Unable to create HomeMatic object".format(self.get_fullname())) self._init_complete = False return # build dict identifier for the homematicIP ccu of this plugin instance if self.port_hmip != 0: self.hmip_id = 'ip' if self.get_instance_name() != '': self.hmip_id += '_' + self.get_instance_name() # create HomeMaticIP object try: self.hmip = HMConnection(interface_id="myserver_ip", autostart=False, eventcallback=self.eventcallback, systemcallback=self.systemcallback, remotes={self.hmip_id:{"ip": self.host, "port": self.port_hmip}}) except: self.logger.error("{}: Unable to create HomeMaticIP object".format(self.get_fullname())) # self._init_complete = False # return # set the name of the thread that got created by pyhomematic to something meaningfull self.hm._server.name = self.get_fullname() # start communication with HomeMatic ccu try: self.hm.start() self.connected = True except: self.logger.error("{}: Unable to start HomeMatic object - SmartHomeNG will be unable to terminate the thread vor this plugin (instance)".format(self.get_fullname())) self.connected = False # self._init_complete = False # stop the thread that got created by initializing pyhomematic # self.hm.stop() # return # start communication with HomeMatic ccu try: self.hmip.start() except: self.logger.error("{}: Unable to start HomeMaticIP object".format(self.get_fullname())) if self.connected: # TO DO: sleep besser lösen! sleep(20) # self.logger.warning("Plugin '{}': self.hm.devices".format(self.hm.devices)) if self.hm.devices.get(self.hm_id,{}) == {}: self.logger.error("{}: Connection to ccu failed".format(self.get_fullname())) # self._init_complete = False # stop the thread that got created by initializing pyhomematic # self.hm.stop() # return self.hm_items = [] if not self.init_webinterface(): # self._init_complete = False pass return def run(self): """ Run method for the plugin """ self.logger.debug("Plugin '{}': run method called".format(self.get_fullname())) self.alive = True # if you want to create child threads, do not make them daemon = True! # They will not shutdown properly. (It's a python bug) def stop(self): """ Stop method for the plugin """ self.logger.debug("Plugin '{}': stop method called".format(self.get_fullname())) self.alive = False self.hm.stop() self.hmip.stop() def parse_item(self, item): """ Default plugin parse_item method. Is called when the plugin is initialized. The plugin can, corresponding to its attribute keywords, decide what to do with the item in future, like adding it to an internal array for future reference :param item: The item to process. :return: If the plugin needs to be informed of an items change you should return a call back function like the function update_item down below. An example when this is needed is the knx plugin where parse_item returns the update_item function when the attribute knx_send is found. This means that when the items value is about to be updated, the call back function is called with the item, caller, source and dest as arguments and in case of the knx plugin the value can be sent to the knx with a knx write function within the knx plugin. """ if self.has_iattr(item.conf, 'hm_address'): init_error = False # self.logger.debug("parse_item{}: {}".format(self.log_instance_str, item)) dev_id = self.get_iattr_value(item.conf, 'hm_address') dev_type = self.get_iattr_value(item.conf, 'hm_type') dev_type = '?' dev = self.hm.devices[self.hm_id].get(dev_id) if dev is None: dev = self.hmip.devices[self.hmip_id].get(dev_id) if dev is not None: dev_type = 'hmIP' else: dev_type = 'hm' hm_address = self.get_iattr_value(item.conf, 'hm_address') hm_channel = self.get_iattr_value(item.conf, 'hm_channel') hm_function = self.get_iattr_value(item.conf, 'hm_function') hm_node = '' if dev is None: self.logger.error("parse_item{}: No HomeMatic device found with address '{}' for {}".format(self.log_instance_str, dev_id, item)) # return else: hm_devicetype = self.get_hmdevicetype( dev_id ) # self.logger.warning("{}, parse_item {}: type='{}', hm_address='{}', hm_channel='{}', hm_function='{}', hm_devicetype='{}'".format(self.get_fullname(), item, item.type(), hm_address, hm_channel, hm_function, hm_devicetype)) # Lookup hm_node and hm_channel for the configured hm_function if hm_function is None: hm_function = 'STATE' hm_channel, hm_node = self.get_hmchannelforfunction(hm_function, hm_channel, dev.ACTIONNODE, 'AC', item) if hm_node == '': hm_channel, hm_node = self.get_hmchannelforfunction(hm_function, hm_channel, dev.ATTRIBUTENODE, 'AT', item) if hm_node == '': hm_channel, hm_node = self.get_hmchannelforfunction(hm_function, hm_channel, dev.BINARYNODE, 'BI', item) if hm_node == '': hm_channel, hm_node = self.get_hmchannelforfunction(hm_function, hm_channel, dev.EVENTNODE, 'EV', item) if hm_node == '': hm_channel, hm_node = self.get_hmchannelforfunction(hm_function, hm_channel, dev.SENSORNODE, 'SE', item) if hm_node == '': hm_channel, hm_node = self.get_hmchannelforfunction(hm_function, hm_channel, dev.WRITENODE, 'WR', item) # self.logger.warning("{}, parse_item {}: dev.ELEMENT='{}'".format(self.get_fullname(), item, dev.ELEMENT)) self.logger.debug("parse_item{}: {}, type='{}', address={}:{}, function='{}', devicetype='{}'".format(self.log_instance_str, item, item.type(), hm_address, hm_channel, hm_function, hm_devicetype)) if hm_node == '': hm_node = None # store item and device information for plugin instance self.hm_items.append( [str(item), item, hm_address, hm_channel, hm_function, hm_node, dev_type] ) # Initialize item from HomeMatic if dev is not None: value = None if hm_node == 'AC': pass # actionNodeData can not be read for initialization init_error = True elif hm_node == 'AT': value = dev.getAttributeData(hm_function) elif hm_node == 'BI': value = dev.getBinaryData(hm_function) elif hm_node == 'EV': value = dev.event(hm_function) elif hm_node == 'SE': value = dev.getSensorData(hm_function) elif hm_node == 'WR': value = dev.getWriteData(hm_function) else: init_error = True self.logger.error("parse_item{}: Not initializing {}: Unknown hm_node='{}' for address={}:{}, function={}".format(self.log_instance_str, item, hm_node, hm_address, hm_channel, hm_function)) if value is not None: self.logger.info("parse_item{}: Initializing {} with '{}' from address={}:{}, function={}".format(self.log_instance_str, item, value, hm_address, hm_channel, hm_function)) item(value, 'HomeMatic', 'Init') else: if not init_error: self.logger.error("parse_item{}: Not initializing {} from address={}:{}, function='{}'".format(self.log_instance_str, item, hm_node, hm_address, hm_channel, hm_function)) return self.update_item def parse_logic(self, logic): """ Default plugin parse_logic method """ if 'xxx' in logic.conf: # self.function(logic['name']) pass def update_item(self, item, caller=None, source=None, dest=None): """ Write items values :param item: item to be updated towards the plugin :param caller: if given it represents the callers name :param source: if given it represents the source :param dest: if given it represents the dest """ if caller != 'HomeMatic': if self.has_iattr(item.conf, 'hm_address'): # self.hm_items[] = [str(item), item, hm_address, hm_channel, hm_function, hm_node] myitem = None for i in self.hm_items: if item == i[1]: myitem = i self.logger.warning("update_item{}: Test: item='{}', caller='{}', hm_function={}, itemvalue='{}'".format(self.log_instance_str, item, caller, i[4], item())) self.logger.warning("update_item{}: Todo: Called with value '{}' for item '{}' from caller '{}', source '{}' and dest '{}'".format(self.log_instance_str, item(), item, caller, source, dest)) dev_id = self.get_iattr_value(item.conf, 'hm_address') dev = self.hm.devices[self.hm_id].get(dev_id) # Write item value to HomeMatic device if dev is not None: hm_node = myitem[5] hm_channel = myitem[3] hm_function = myitem[4] dev.CHANNELS[int(hm_channel)].setValue(hm_function, item()) self.logger.warning("{}, update_item (hm): Called with value '{}' for item '{}' from caller '{}', source '{}' and dest '{}'".format(self.get_fullname(), item(), item, caller, source, dest)) else: dev = self.hmip.devices[self.hmip_id].get(dev_id) # Write item value to HomeMaticIP device if dev is not None: hm_node = myitem[5] hm_channel = myitem[3] hm_function = myitem[4] dev.CHANNELS[int(hm_channel)].setValue(hm_function, item()) self.logger.warning("{}, update_item (hmIP): Called with value '{}' for item '{}' from caller '{}', source '{}' and dest '{}'".format(self.get_fullname(), item(), item, caller, source, dest)) # ACTIONNODE: PRESS_LONG (action), PRESS_SHORT (action), [LEVEL (float 0.0-1.0)] # LEVEL (float: 0.0-1.0), STOP (action), INHIBIT (bool), INSTALL_TEST (action), # OLD_LEVEL (action), RAMP_TIME (float 0.0-85825945.6 s), RAMP_STOP (action) # # Heizkörperthermostat (HM-CC-RT-DN): # SET_TEMPERATURE (float -10.0-50.0), AUTO_MODE (action), MANU_MODE (float 4.5-30.5), BOOST_MODE (action), COMFORT_MODE (action), LOWERING_MODE (action), # PARTY_MODE_SUBMIT (string), PARTY_TEMPERATURE (float 5.0-30.0), PARTY_START_TIME (int 0-1410), PARTY_START_DAY (int 0-31), PARTY_START_MONTH (int 1-12), PARTY_START_YEAR (int 0-99), # PARTY_STOP_TIME (int), PARTY_STOP_DAY (int), PARTY_STOP_MONTH (int), PARTY_STOP_YEAR (int) # # Heizkörperthermostat (HM-CC-RT-DN-BoM): # CLEAR_WINDOW_OPEN_SYMBOL (int 0-1), SET_SYMBOL_FOR_HEATING_PHASE (int 0-1), ... # # Funk- Wandthermostat ab V2.0 (CLIMATECONTROL_REGULATOR) # SETPOINT (float 6.0-30.0) # # KeyMatic: # RELOCK_DELAY (float 0.0-65535.0) # # Statusanzeige 16Kanal LED # LED_STATUS (option 0=OFF, 1=RED, 2=GREEN, 3=ORANGE), ALL_LEDS (string), LED_SLEEP_MODE (option 0=OFF, 1=ON) # # Funk- Fernbedienung 19 Tasten mit Display # TEXT (string), BULB (action), SWITCH (action), WINDOW (action), DOOR (action), BLIND (action), SCENE (action), PHONE (action), # BELL (action), CLOCK (action), ARROW_UP (action), ARROW_DOWN (action), UNIT (option 0=NONE, 1=PERCENT, 2=WATT, 3=CELSIUS, 4=FAHRENHEIT), # BEEP (option 0=NONE, 1-3=TONE1-3), BACKLIGHT (option 0=OFF, 1=ON, 2=BLINK_SLOW, 3=BLINK_FAST), # SUBMIT (action), ALARM_COUNT (int 0-255), SERVICE_COUNT (int 0-255) # # ON_TIME (float 0.0-85825945.6 s), SUBMIT (string) # STATE, LEVEL, STOP (action) def init_webinterface(self): """" Initialize the web interface for this plugin This method is only needed if the plugin is implementing a web interface """ try: self.mod_http = Modules.get_instance().get_module('http') # try/except to handle running in a core version that does not support modules except: self.mod_http = None if self.mod_http == None: self.logger.error("Plugin '{}': Not initializing the web interface".format(self.get_shortname())) return False import sys if not "SmartPluginWebIf" in list(sys.modules['lib.model.smartplugin'].__dict__): self.logger.warning("Plugin '{}': Web interface needs SmartHomeNG v1.5 and up. Not initializing the web interface".format(self.get_shortname())) return False # set application configuration for cherrypy webif_dir = self.path_join(self.get_plugin_dir(), 'webif') config = { '/': { 'tools.staticdir.root': webif_dir, }, '/static': { 'tools.staticdir.on': True, 'tools.staticdir.dir': 'static' } } # Register the web interface as a cherrypy app self.mod_http.register_webif(WebInterface(webif_dir, self), self.get_shortname(), config, self.get_classname(), self.get_instance_name(), description='') return True # --------------------------------------------------------- # Methods of the plugin class for the external device # --------------------------------------------------------- def get_hmdevicetype(self, dev_id): """ get the devicetype for the given device id :param dev_id: HomeMatic device id :param type: str :return: device type :rtype: str """ dev = self.hm.devices[self.hm_id].get(dev_id) if dev is not None: d_type = str(dev.__class__).replace("<class '"+dev.__module__+'.', '').replace("'>",'') return d_type dev = self.hmip.devices[self.hmip_id].get(dev_id) if dev is not None: d_type = str(dev.__class__).replace("<class '"+dev.__module__+'.', '').replace("'>",'') return d_type return '' def get_hmchannelforfunction(self, hm_function, hm_channel, node, hm_node, item): """ Returns the HomeMatic Channel of the deivce for the wanted function :param hm_function: Configured function (or STATE) :param hm_channel: Preconfigured channel or None :param node: the node attribute of the Homematic device (e.g. dev.BINARYNODE) :param hm_node: short string for the nodename (AT, AC, BI, EV, SE, WR) """ if hm_function in node.keys(): if hm_channel is None: hm_channel = node[hm_function][0] else: if not int(hm_channel) in node[hm_function]: hm_node = '' self.logger.error("get_hmchannelforfunction{}: Invalid channel '{}' specified for {}".format(self.log_instance_str, hm_channel, item)) else: hm_node = '' return hm_channel, hm_node def systemcallback(self, src, *args): self.logger.info("systemcallback{}: src = '{}', args = '{}'".format(self.log_instance_str, src, args)) def eventcallback(self, interface_id, address, value_key, value): """ Callback method for HomeMatic events This method is called whenever the HomeMatic ccu processs an event """ defined = False for i in self.hm_items: if address == i[2]+':'+str(i[3]): if value_key == i[4]: self.logger.info("eventcallback{}: address={}, {}='{}' -> {}".format(self.log_instance_str, address, value_key, value, i[0])) # i[1](value, 'HomeMatic', address) i[1](value, 'HomeMatic') defined = True if not defined: self.logger.debug("eventcallback{}: Ohne item Zuordnung: interface_id = '{}', address = '{}', {} = '{}'".format(self.log_instance_str, interface_id, address, value_key, value))
def __init__(self, sh, *args, **kwargs): """ Initalizes the plugin. If you need the sh object at all, use the method self.get_sh() to get it. There should be almost no need for a reference to the sh object any more. Plugins have to use the new way of getting parameter values: use the SmartPlugin method get_parameter_value(parameter_name). Anywhere within the Plugin you can get the configured (and checked) value for a parameter by calling self.get_parameter_value(parameter_name). It returns the value in the datatype that is defined in the metadata. """ # Call init code of parent class (SmartPlugin) super().__init__() # get the parameters for the plugin (as defined in metadata plugin.yaml): # self.param1 = self.get_parameter_value('param1') # Initialization code goes here self.username = self.get_parameter_value('username') self.password = self.get_parameter_value('password') self.host = self.get_parameter_value('host') # self.port = self.get_parameter_value('port') # self.port_hmip = self.get_parameter_value('port_hmip') self.port = 2001 self.port_hmip = 2010 # build dict identifier for the homematic ccu of this plugin instance self.hm_id = 'rf' if self.get_instance_name() != '': self.hm_id += '_' + self.get_instance_name() # create HomeMatic object try: self.hm = HMConnection( interface_id="myserver", autostart=False, eventcallback=self.eventcallback, systemcallback=self.systemcallback, remotes={self.hm_id: { "ip": self.host, "port": self.port }}) # remotes={self.hm_id:{"ip": self.host, "port": self.port}, self.hmip_id:{"ip": self.host, "port": self.port_hmip}}) except: self.logger.error("Unable to create HomeMatic object") self._init_complete = False return # build dict identifier for the homematicIP ccu of this plugin instance if self.port_hmip != 0: self.hmip_id = 'ip' if self.get_instance_name() != '': self.hmip_id += '_' + self.get_instance_name() # create HomeMaticIP object try: self.hmip = HMConnection(interface_id="myserver_ip", autostart=False, eventcallback=self.eventcallback, systemcallback=self.systemcallback, remotes={ self.hmip_id: { "ip": self.host, "port": self.port_hmip } }) except: self.logger.error("Unable to create HomeMaticIP object") # self._init_complete = False # return # set the name of the thread that got created by pyhomematic to something meaningfull self.hm._server.name = 'plugins.' + self.get_fullname() + '.server' # start communication with HomeMatic ccu try: self.hm.start() self.connected = True except: self.logger.error( "Unable to start HomeMatic object - SmartHomeNG will be unable to terminate the thread vor this plugin (instance)" ) self.connected = False # self._init_complete = False # stop the thread that got created by initializing pyhomematic # self.hm.stop() # return # start communication with HomeMatic ccu try: self.hmip.start() except: self.logger.error("{}: Unable to start HomeMaticIP object".format( self.get_fullname())) if self.connected: # TO DO: sleep besser lösen! sleep(20) # self.logger.warning("Plugin '{}': self.hm.devices".format(self.hm.devices)) if self.hm.devices.get(self.hm_id, {}) == {}: self.logger.error("Connection to ccu failed") # self._init_complete = False # stop the thread that got created by initializing pyhomematic # self.hm.stop() # return self.hm_items = [] self.init_webinterface(WebInterface) return
def setup(hass, config): """Setup the Homematic component.""" from pyhomematic import HMConnection component = EntityComponent(_LOGGER, DOMAIN, hass) hass.data[DATA_DELAY] = config[DOMAIN].get(CONF_DELAY) hass.data[DATA_DEVINIT] = {} hass.data[DATA_STORE] = [] # create hosts list for pyhomematic remotes = {} hosts = {} for rname, rconfig in config[DOMAIN][CONF_HOSTS].items(): server = rconfig.get(CONF_IP) remotes[rname] = {} remotes[rname][CONF_IP] = server remotes[rname][CONF_PORT] = rconfig.get(CONF_PORT) remotes[rname][CONF_RESOLVENAMES] = rconfig.get(CONF_RESOLVENAMES) remotes[rname][CONF_USERNAME] = rconfig.get(CONF_USERNAME) remotes[rname][CONF_PASSWORD] = rconfig.get(CONF_PASSWORD) if server not in hosts or rconfig.get(CONF_PRIMARY): hosts[server] = { CONF_VARIABLES: rconfig.get(CONF_VARIABLES), CONF_NAME: rname, } hass.data[DATA_DEVINIT][rname] = rconfig.get(CONF_DEVICES) # Create server thread bound_system_callback = partial(_system_callback_handler, hass, config) hass.data[DATA_HOMEMATIC] = HMConnection( local=config[DOMAIN].get(CONF_LOCAL_IP), localport=config[DOMAIN].get(CONF_LOCAL_PORT), remotes=remotes, systemcallback=bound_system_callback, interface_id="homeassistant") # Start server thread, connect to peer, initialize to receive events hass.data[DATA_HOMEMATIC].start() # Stops server when Homeassistant is shutting down hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, hass.data[DATA_HOMEMATIC].stop) hass.config.components.append(DOMAIN) # init homematic hubs hub_entities = [] for _, hub_data in hosts.items(): hub_entities.append( HMHub(hass, component, hub_data[CONF_NAME], hub_data[CONF_VARIABLES])) component.add_entities(hub_entities) # regeister homematic services descriptions = load_yaml_config_file( os.path.join(os.path.dirname(__file__), 'services.yaml')) def _hm_service_virtualkey(service): """Service handle virtualkey services.""" address = service.data.get(ATTR_ADDRESS) channel = service.data.get(ATTR_CHANNEL) param = service.data.get(ATTR_PARAM) # device not found hmdevice = _device_from_servicecall(hass, service) if hmdevice is None: _LOGGER.error("%s not found for service virtualkey!", address) return # if param exists for this device if param not in hmdevice.ACTIONNODE: _LOGGER.error("%s not datapoint in hm device %s", param, address) return # channel exists? if channel not in hmdevice.ACTIONNODE[param]: _LOGGER.error("%i is not a channel in hm device %s", channel, address) return # call key hmdevice.actionNodeData(param, True, channel) hass.services.register(DOMAIN, SERVICE_VIRTUALKEY, _hm_service_virtualkey, descriptions[DOMAIN][SERVICE_VIRTUALKEY], schema=SCHEMA_SERVICE_VIRTUALKEY) def _service_handle_value(service): """Set value on homematic variable object.""" variable_list = component.extract_from_service(service) value = service.data[ATTR_VALUE] for hm_variable in variable_list: if isinstance(hm_variable, HMVariable): hm_variable.hm_set(value) hass.services.register(DOMAIN, SERVICE_SET_VAR_VALUE, _service_handle_value, descriptions[DOMAIN][SERVICE_SET_VAR_VALUE], schema=SCHEMA_SERVICE_SET_VAR_VALUE) def _service_handle_reconnect(service): """Reconnect to all homematic hubs.""" hass.data[DATA_HOMEMATIC].reconnect() hass.services.register(DOMAIN, SERVICE_RECONNECT, _service_handle_reconnect, descriptions[DOMAIN][SERVICE_RECONNECT], schema=SCHEMA_SERVICE_RECONNECT) def _service_handle_device(service): """Service handle set_dev_value services.""" address = service.data.get(ATTR_ADDRESS) channel = service.data.get(ATTR_CHANNEL) param = service.data.get(ATTR_PARAM) value = service.data.get(ATTR_VALUE) # device not found hmdevice = _device_from_servicecall(hass, service) if hmdevice is None: _LOGGER.error("%s not found!", address) return # call key hmdevice.setValue(param, value, channel) hass.services.register(DOMAIN, SERVICE_SET_DEV_VALUE, _service_handle_device, descriptions[DOMAIN][SERVICE_SET_DEV_VALUE], schema=SCHEMA_SERVICE_SET_DEV_VALUE) return True
def __init__(self, sh, *args, **kwargs): """ Initalizes the plugin. The parameters descriptions for this method are pulled from the entry in plugin.yaml. :param sh: **Deprecated**: The instance of the smarthome object. For SmartHomeNG versions **beyond** 1.3: **Don't use it**! :param *args: **Deprecated**: Old way of passing parameter values. For SmartHomeNG versions **beyond** 1.3: **Don't use it**! :param **kwargs:**Deprecated**: Old way of passing parameter values. For SmartHomeNG versions **beyond** 1.3: **Don't use it**! If you need the sh object at all, use the method self.get_sh() to get it. There should be almost no need for a reference to the sh object any more. The parameters *args and **kwargs are the old way of passing parameters. They are deprecated. They are imlemented to support older plugins. Plugins for SmartHomeNG v1.4 and beyond should use the new way of getting parameter values: use the SmartPlugin method get_parameter_value(parameter_name) instead. Anywhere within the Plugin you can get the configured (and checked) value for a parameter by calling self.get_parameter_value(parameter_name). It returns the value in the datatype that is defined in the metadata. """ self.logger = logging.getLogger(__name__) # get the parameters for the plugin (as defined in metadata plugin.yaml): # self.param1 = self.get_parameter_value('param1') # Initialization code goes here self.username = self.get_parameter_value('username') self.password = self.get_parameter_value('password') self.host = self.get_parameter_value('host') # self.port = self.get_parameter_value('port') # self.port_hmip = self.get_parameter_value('port_hmip') self.port = 2001 self.port_hmip = 2010 # build dict identifier for the homematic ccu of this plugin instance self.hm_id = 'rf' if self.get_instance_name() != '': self.hm_id += '_' + self.get_instance_name() self.log_instance_str = ' ('+self.get_instance_name()+')' else: self.log_instance_str = '' # create HomeMatic object try: self.hm = HMConnection(interface_id="myserver", autostart=False, eventcallback=self.eventcallback, systemcallback=self.systemcallback, remotes={self.hm_id:{"ip": self.host, "port": self.port}}) # remotes={self.hm_id:{"ip": self.host, "port": self.port}, self.hmip_id:{"ip": self.host, "port": self.port_hmip}}) except: self.logger.error("{}: Unable to create HomeMatic object".format(self.get_fullname())) self._init_complete = False return # build dict identifier for the homematicIP ccu of this plugin instance if self.port_hmip != 0: self.hmip_id = 'ip' if self.get_instance_name() != '': self.hmip_id += '_' + self.get_instance_name() # create HomeMaticIP object try: self.hmip = HMConnection(interface_id="myserver_ip", autostart=False, eventcallback=self.eventcallback, systemcallback=self.systemcallback, remotes={self.hmip_id:{"ip": self.host, "port": self.port_hmip}}) except: self.logger.error("{}: Unable to create HomeMaticIP object".format(self.get_fullname())) # self._init_complete = False # return # set the name of the thread that got created by pyhomematic to something meaningfull self.hm._server.name = self.get_fullname() # start communication with HomeMatic ccu try: self.hm.start() self.connected = True except: self.logger.error("{}: Unable to start HomeMatic object - SmartHomeNG will be unable to terminate the thread vor this plugin (instance)".format(self.get_fullname())) self.connected = False # self._init_complete = False # stop the thread that got created by initializing pyhomematic # self.hm.stop() # return # start communication with HomeMatic ccu try: self.hmip.start() except: self.logger.error("{}: Unable to start HomeMaticIP object".format(self.get_fullname())) if self.connected: # TO DO: sleep besser lösen! sleep(20) # self.logger.warning("Plugin '{}': self.hm.devices".format(self.hm.devices)) if self.hm.devices.get(self.hm_id,{}) == {}: self.logger.error("{}: Connection to ccu failed".format(self.get_fullname())) # self._init_complete = False # stop the thread that got created by initializing pyhomematic # self.hm.stop() # return self.hm_items = [] if not self.init_webinterface(): # self._init_complete = False pass return
def setup(hass, config): """Set up the Homematic component.""" from pyhomematic import HMConnection conf = config[DOMAIN] hass.data[DATA_CONF] = remotes = {} hass.data[DATA_STORE] = set() # Create hosts-dictionary for pyhomematic for rname, rconfig in conf[CONF_INTERFACES].items(): remotes[rname] = { 'ip': socket.gethostbyname(rconfig.get(CONF_HOST)), 'port': rconfig.get(CONF_PORT), 'path': rconfig.get(CONF_PATH), 'resolvenames': rconfig.get(CONF_RESOLVENAMES), 'username': rconfig.get(CONF_USERNAME), 'password': rconfig.get(CONF_PASSWORD), 'callbackip': rconfig.get(CONF_CALLBACK_IP), 'callbackport': rconfig.get(CONF_CALLBACK_PORT), 'connect': True, } for sname, sconfig in conf[CONF_HOSTS].items(): remotes[sname] = { 'ip': socket.gethostbyname(sconfig.get(CONF_HOST)), 'port': DEFAULT_PORT, 'username': sconfig.get(CONF_USERNAME), 'password': sconfig.get(CONF_PASSWORD), 'connect': False, } # Create server thread bound_system_callback = partial(_system_callback_handler, hass, config) hass.data[DATA_HOMEMATIC] = homematic = HMConnection( local=config[DOMAIN].get(CONF_LOCAL_IP), localport=config[DOMAIN].get(CONF_LOCAL_PORT), remotes=remotes, systemcallback=bound_system_callback, interface_id='homeassistant' ) # Start server thread, connect to hosts, initialize to receive events homematic.start() # Stops server when HASS is shutting down hass.bus.listen_once( EVENT_HOMEASSISTANT_STOP, hass.data[DATA_HOMEMATIC].stop) # Init homematic hubs entity_hubs = [] for hub_name in conf[CONF_HOSTS].keys(): entity_hubs.append(HMHub(hass, homematic, hub_name)) def _hm_service_virtualkey(service): """Service to handle virtualkey servicecalls.""" address = service.data.get(ATTR_ADDRESS) channel = service.data.get(ATTR_CHANNEL) param = service.data.get(ATTR_PARAM) # Device not found hmdevice = _device_from_servicecall(hass, service) if hmdevice is None: _LOGGER.error("%s not found for service virtualkey!", address) return # Parameter doesn't exist for device if param not in hmdevice.ACTIONNODE: _LOGGER.error("%s not datapoint in hm device %s", param, address) return # Channel doesn't exist for device if channel not in hmdevice.ACTIONNODE[param]: _LOGGER.error("%i is not a channel in hm device %s", channel, address) return # Call parameter hmdevice.actionNodeData(param, True, channel) hass.services.register( DOMAIN, SERVICE_VIRTUALKEY, _hm_service_virtualkey, schema=SCHEMA_SERVICE_VIRTUALKEY) def _service_handle_value(service): """Service to call setValue method for HomeMatic system variable.""" entity_ids = service.data.get(ATTR_ENTITY_ID) name = service.data[ATTR_NAME] value = service.data[ATTR_VALUE] if entity_ids: entities = [entity for entity in entity_hubs if entity.entity_id in entity_ids] else: entities = entity_hubs if not entities: _LOGGER.error("No HomeMatic hubs available") return for hub in entities: hub.hm_set_variable(name, value) hass.services.register( DOMAIN, SERVICE_SET_VARIABLE_VALUE, _service_handle_value, schema=SCHEMA_SERVICE_SET_VARIABLE_VALUE) def _service_handle_reconnect(service): """Service to reconnect all HomeMatic hubs.""" homematic.reconnect() hass.services.register( DOMAIN, SERVICE_RECONNECT, _service_handle_reconnect, schema=SCHEMA_SERVICE_RECONNECT) def _service_handle_device(service): """Service to call setValue method for HomeMatic devices.""" address = service.data.get(ATTR_ADDRESS) channel = service.data.get(ATTR_CHANNEL) param = service.data.get(ATTR_PARAM) value = service.data.get(ATTR_VALUE) # Device not found hmdevice = _device_from_servicecall(hass, service) if hmdevice is None: _LOGGER.error("%s not found!", address) return hmdevice.setValue(param, value, channel) hass.services.register( DOMAIN, SERVICE_SET_DEVICE_VALUE, _service_handle_device, schema=SCHEMA_SERVICE_SET_DEVICE_VALUE) def _service_handle_install_mode(service): """Service to set interface into install mode.""" interface = service.data.get(ATTR_INTERFACE) mode = service.data.get(ATTR_MODE) time = service.data.get(ATTR_TIME) address = service.data.get(ATTR_ADDRESS) homematic.setInstallMode(interface, t=time, mode=mode, address=address) hass.services.register( DOMAIN, SERVICE_SET_INSTALL_MODE, _service_handle_install_mode, schema=SCHEMA_SERVICE_SET_INSTALL_MODE) return True
def setup(hass, config): """Set up the Homematic component.""" conf = config[DOMAIN] hass.data[DATA_CONF] = remotes = {} hass.data[DATA_STORE] = set() # Create hosts-dictionary for pyhomematic for rname, rconfig in conf[CONF_INTERFACES].items(): remotes[rname] = { "ip": rconfig.get(CONF_HOST), "port": rconfig.get(CONF_PORT), "path": rconfig.get(CONF_PATH), "resolvenames": rconfig.get(CONF_RESOLVENAMES), "jsonport": rconfig.get(CONF_JSONPORT), "username": rconfig.get(CONF_USERNAME), "password": rconfig.get(CONF_PASSWORD), "callbackip": rconfig.get(CONF_CALLBACK_IP), "callbackport": rconfig.get(CONF_CALLBACK_PORT), "ssl": rconfig.get(CONF_SSL), "verify_ssl": rconfig.get(CONF_VERIFY_SSL), "connect": True, } for sname, sconfig in conf[CONF_HOSTS].items(): remotes[sname] = { "ip": sconfig.get(CONF_HOST), "port": DEFAULT_PORT, "username": sconfig.get(CONF_USERNAME), "password": sconfig.get(CONF_PASSWORD), "connect": False, } # Create server thread bound_system_callback = partial(_system_callback_handler, hass, config) hass.data[DATA_HOMEMATIC] = homematic = HMConnection( local=config[DOMAIN].get(CONF_LOCAL_IP), localport=config[DOMAIN].get(CONF_LOCAL_PORT, DEFAULT_LOCAL_PORT), remotes=remotes, systemcallback=bound_system_callback, interface_id="homeassistant", ) # Start server thread, connect to hosts, initialize to receive events homematic.start() # Stops server when HASS is shutting down hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, hass.data[DATA_HOMEMATIC].stop) # Init homematic hubs entity_hubs = [] for hub_name in conf[CONF_HOSTS].keys(): entity_hubs.append(HMHub(hass, homematic, hub_name)) def _hm_service_virtualkey(service): """Service to handle virtualkey servicecalls.""" address = service.data.get(ATTR_ADDRESS) channel = service.data.get(ATTR_CHANNEL) param = service.data.get(ATTR_PARAM) # Device not found hmdevice = _device_from_servicecall(hass, service) if hmdevice is None: _LOGGER.error("%s not found for service virtualkey!", address) return # Parameter doesn't exist for device if param not in hmdevice.ACTIONNODE: _LOGGER.error("%s not datapoint in hm device %s", param, address) return # Channel doesn't exist for device if channel not in hmdevice.ACTIONNODE[param]: _LOGGER.error("%i is not a channel in hm device %s", channel, address) return # Call parameter hmdevice.actionNodeData(param, True, channel) hass.services.register( DOMAIN, SERVICE_VIRTUALKEY, _hm_service_virtualkey, schema=SCHEMA_SERVICE_VIRTUALKEY, ) def _service_handle_value(service): """Service to call setValue method for HomeMatic system variable.""" entity_ids = service.data.get(ATTR_ENTITY_ID) name = service.data[ATTR_NAME] value = service.data[ATTR_VALUE] if entity_ids: entities = [ entity for entity in entity_hubs if entity.entity_id in entity_ids ] else: entities = entity_hubs if not entities: _LOGGER.error("No HomeMatic hubs available") return for hub in entities: hub.hm_set_variable(name, value) hass.services.register( DOMAIN, SERVICE_SET_VARIABLE_VALUE, _service_handle_value, schema=SCHEMA_SERVICE_SET_VARIABLE_VALUE, ) def _service_handle_reconnect(service): """Service to reconnect all HomeMatic hubs.""" homematic.reconnect() hass.services.register( DOMAIN, SERVICE_RECONNECT, _service_handle_reconnect, schema=SCHEMA_SERVICE_RECONNECT, ) def _service_handle_device(service): """Service to call setValue method for HomeMatic devices.""" address = service.data.get(ATTR_ADDRESS) channel = service.data.get(ATTR_CHANNEL) param = service.data.get(ATTR_PARAM) value = service.data.get(ATTR_VALUE) value_type = service.data.get(ATTR_VALUE_TYPE) # Convert value into correct XML-RPC Type. # https://docs.python.org/3/library/xmlrpc.client.html#xmlrpc.client.ServerProxy if value_type: if value_type == "int": value = int(value) elif value_type == "double": value = float(value) elif value_type == "boolean": value = bool(value) elif value_type == "dateTime.iso8601": value = datetime.strptime(value, "%Y%m%dT%H:%M:%S") else: # Default is 'string' value = str(value) # Device not found hmdevice = _device_from_servicecall(hass, service) if hmdevice is None: _LOGGER.error("%s not found!", address) return hmdevice.setValue(param, value, channel) hass.services.register( DOMAIN, SERVICE_SET_DEVICE_VALUE, _service_handle_device, schema=SCHEMA_SERVICE_SET_DEVICE_VALUE, ) def _service_handle_install_mode(service): """Service to set interface into install mode.""" interface = service.data.get(ATTR_INTERFACE) mode = service.data.get(ATTR_MODE) time = service.data.get(ATTR_TIME) address = service.data.get(ATTR_ADDRESS) homematic.setInstallMode(interface, t=time, mode=mode, address=address) hass.services.register( DOMAIN, SERVICE_SET_INSTALL_MODE, _service_handle_install_mode, schema=SCHEMA_SERVICE_SET_INSTALL_MODE, ) def _service_put_paramset(service): """Service to call the putParamset method on a HomeMatic connection.""" interface = service.data.get(ATTR_INTERFACE) address = service.data.get(ATTR_ADDRESS) paramset_key = service.data.get(ATTR_PARAMSET_KEY) # When passing in the paramset from a YAML file we get an OrderedDict # here instead of a dict, so add this explicit cast. # The service schema makes sure that this cast works. paramset = dict(service.data.get(ATTR_PARAMSET)) _LOGGER.debug( "Calling putParamset: %s, %s, %s, %s", interface, address, paramset_key, paramset, ) homematic.putParamset(interface, address, paramset_key, paramset) hass.services.register( DOMAIN, SERVICE_PUT_PARAMSET, _service_put_paramset, schema=SCHEMA_SERVICE_PUT_PARAMSET, ) return True