pyhausbus 1.0.0__tar.gz

pyhausbus-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Hermann Hoeschen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyhausbus-1.0.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.1
+Name: pyhausbus
+Version: 1.0.0
+Summary: Python based library for accessing haus-bus.de modules. Inteded to be used in a Home Assistant integration.
+Author: Hermann Hoeschen
+Author-email: info@haus-bus.de
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+
+# pyhausbus
+
+Python based library for accessing haus-bus.de modules. Intended to be used in a Home Assistant integration.
+

pyhausbus-1.0.0/README.md

@@ -0,0 +1,3 @@
+# pyhausbus
+
+Python based library for accessing haus-bus.de modules. Intended to be used in a Home Assistant integration.

pyhausbus-1.0.0/pyhausbus/ABusFeature.py

@@ -0,0 +1,22 @@
+from pyhausbus.HausBusUtils import LOGGER
+from pyhausbus.ObjectId import ObjectId
+
+class ABusFeature:
+
+  def __init__(self, objectId:int):
+    self.objectId = objectId
+    self.name:str=""
+
+  def getObjectId(self) -> int:
+    return self.objectId
+
+  def getName(self) -> str:
+    return self.name
+
+  def setName(self, name:str):
+      self.name = name
+
+  def __str__(self):
+    dummy, classType = str(type(self)).rsplit(".", 1)
+    classType = classType[:-2]
+    return f"ABusFeature(type={classType}, name={self.name}, objectId={ObjectId(self.objectId)}"

pyhausbus-1.0.0/pyhausbus/BusDataMessage.py

@@ -0,0 +1,23 @@
+import pyhausbus.HausBusUtils as HausBusUtils
+
+
+class BusDataMessage:
+
+  def __init__(self, senderObjectId, receiverObjectId, data):
+    self.senderObjectId = senderObjectId
+    self.receiverObjectId = receiverObjectId
+    self.data = data
+    self.time = HausBusUtils.getClockIndependMillis()
+
+  def getSenderObjectId(self):
+    return self.senderObjectId
+
+  def getReceiverObjectId(self):
+    return self.receiverObjectId
+
+  def getData(self):
+    return self.data
+
+  def __str__(self):
+    return f"BusMessage(senderObjectId={self.senderObjectId}, receiverObjectId={self.receiverObjectId}, data={self.data})"
+

pyhausbus-1.0.0/pyhausbus/BusHandler.py

@@ -0,0 +1,110 @@
+import threading
+from pyhausbus.de.hausbus.homeassistant.proxy import ProxyFactory
+from pyhausbus.HausBusUtils import *
+from pyhausbus.BusDataMessage import BusDataMessage
+from pyhausbus.IBusDataListener import IBusDataListener
+import time
+import importlib
+from pyhausbus.UdpReceiveWorker import UdpReceiveWorker
+import socket
+import pyhausbus.HausBusUtils as HausBusUtils
+import traceback
+
+RS485_GATEWAY = "#RS485#"
+EVENTS_START = 200
+RESULT_START = 128
+
+class BusHandler:
+
+  _singleInstance = None
+  sock:None
+  broadcastIp = "192.168.178.255"
+  listeners = []
+
+  @staticmethod
+  def getInstance():
+    if BusHandler._singleInstance is None:
+      BusHandler._singleInstance = BusHandler()
+    return BusHandler._singleInstance
+
+  def __init__(self):
+    if BusHandler._singleInstance is None:
+      self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+      self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+      x = UdpReceiveWorker(self.busDataReceived)
+      x.startWorker()
+      self._getBroadcastIp()
+
+  def _getBroadcastIp(self):
+    temp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        temp_socket.connect(("8.8.8.8", 80))
+        own_ip = temp_socket.getsockname()[0].split('.')
+        self.broadcastIp = own_ip[0] + "." + own_ip[1] + "." + own_ip[2] + ".255"
+    finally:
+        temp_socket.close()
+
+  def busDataReceived(self, senderObjectId, receiverObjectId, functionId, functionData, gateway, corrupted:bool):
+    # Es kann entweder eine Antwort oder Event des Senders sein oder ein Aufruf auf dem Empfänger
+    featureClassId = 0
+    identifierId = 0
+    if (functionId < RESULT_START):
+      featureClassId = getClassId(receiverObjectId)
+      identifierId = receiverObjectId
+    else:
+      featureClassId = getClassId(senderObjectId)
+      identifierId = senderObjectId
+
+    LOGGER.debug("classId = " + str(featureClassId) + ", functionId = " + str(functionId))
+    className = ProxyFactory.getBusClassNameFor(featureClassId, functionId)
+    if (className=="de.hausbus.proxy.LogicalButton"):
+      LOGGER.debug("test")
+
+    try:
+      module_name, class_name = className.rsplit(".", 1)
+      module = importlib.import_module(className)
+      cls = getattr(module, class_name)
+      method = getattr(cls, "_fromBytes")
+      offset = [0]
+      newObject = method(functionData, offset)
+
+      add = ""
+      if (corrupted):
+        add = " (corrupted) "
+
+      message = gateway + " COMMAND IN " + add + " from " + str(getDeviceId(senderObjectId)) + " to " + str(getDeviceId(receiverObjectId)) + ": " + str(newObject) + ", Sender: " + formatObjectId(senderObjectId) + ", Receiver: " + str(formatObjectId(receiverObjectId))
+      LOGGER.debug(message)
+
+      if (not corrupted):
+        newMessage = BusDataMessage(senderObjectId, receiverObjectId, newObject)
+        LOGGER.debug("got: " + str(newObject) + " from " + str(senderObjectId) + " to " + str(receiverObjectId))
+        for actListener in self.listeners:
+          actListener.busDataReceived(newMessage)
+    except (Exception, RuntimeError, TypeError, NameError, OSError) as err:
+        LOGGER.error(err,exc_info=True,stack_info=True)
+
+  def sendData(self, data:bytearray, debug:str):
+
+    udpData:bytearray = self.prepareForUDP(data)
+
+    LOGGER.debug(UdpReceiveWorker.UDP_GATEWAY + " COMMAND OUT " + debug)
+    LOGGER.debug(UdpReceiveWorker.UDP_GATEWAY + " DATA OUT " + HausBusUtils.formatBytes(udpData))
+
+    try:
+      self.sock.sendto(udpData, (self.broadcastIp, UDP_PORT))
+    except socket.error as e:
+      LOGGER.error(e,exc_info=True,stack_info=True)
+
+  def prepareForUDP(self, data:bytearray) -> bytearray:
+    result = bytearray(len(data) + 2)
+    result[0] = 0xef
+    result[1] = 0xef
+    result[2:] = data[:]
+    return result
+
+  def addBusEventListener(self, listener:IBusDataListener):
+    if not listener in self.listeners:
+      self.listeners.append(listener)
+
+  def removeBusEventListener(self, listener:IBusDataListener):
+    self.listeners.remove(listener)

pyhausbus-1.0.0/pyhausbus/HausBusCommand.py

@@ -0,0 +1,84 @@
+from pyhausbus.BusHandler import BusHandler
+import pyhausbus.HausBusUtils as HausBusUtils
+from pyhausbus.HausBusUtils import LOGGER
+from pyhausbus.ObjectId import ObjectId
+
+class HausBusCommand:
+
+  def __init__ (self, receiverObjectId:int, functionId:int, debug:str):
+    self.commandCounter:int = 0
+    self.receiverObjectId = receiverObjectId
+    self.debug = debug
+    self.busHandler = BusHandler.getInstance()
+    self.data:bytearray=bytearray()
+    self.params:bytearray=bytearray()
+    self.bytes:bytearray=None
+
+    # Kontroll-Byte
+    self.data.append(0)
+
+    # Nachrichtenzaehler
+    self.data.append(0)
+
+    # Sender-ID
+    for act in HausBusUtils.dWordToBytes(HausBusUtils.HOMESERVER_OBJECT_ID):
+      self.data.append(act)
+
+    # Empfaenger-ID
+    for act in HausBusUtils.dWordToBytes(receiverObjectId):
+      self.data.append(act)
+
+    self.params.append(functionId)
+
+  def addByte(self, byteParam:int):
+    self.params.append(byteParam)
+
+  def addSByte(self, sByteParam:int):
+    if (sByteParam < 0):
+      self.params.append((256 + sByteParam))
+    else:
+      self.params.append(sByteParam)
+
+  def addBlob(self, blob:bytearray):
+    for act in blob:
+      self.params.append(act)
+
+  def addString(self, value:str):
+    for i in range(len(value)):
+      self.params.append(value[i])
+    self.params.append(0)
+
+  def addMap(self, inMap):
+    for key, value in inMap.items():
+      self.addByte(key)
+      self.addByte(value)
+
+  def addWord(self, wordParam:int):
+    HausBusUtils.addWord(wordParam, self.params)
+
+  def addDWord(self, dWordParam:int):
+    HausBusUtils.addDword(dWordParam, self.params)
+
+  def _createBytes(self):
+
+    # Datenlaenge
+    for act in HausBusUtils.wordToBytes(len(self.params)):
+      self.data.append(act)
+
+    # Daten
+    for act in self.params:
+      self.data.append(act)
+
+    self.bytes = bytearray(len(self.data))
+    for i in range (len(self.data)):
+      self.bytes[i] = self.data[i]
+
+  def send(self):
+    LOGGER.debug("Sende " + self.debug + " an " + str(ObjectId(self.receiverObjectId)))
+    if (self.bytes == None):
+      self._createBytes()
+
+    return self.busHandler.sendData(self.bytes, self.debug + " to " + str(HausBusUtils.getDeviceId(self.receiverObjectId)))
+
+  def __str__(self):
+    return f"HausBusCommand(debug={self.debug} to {HausBusUtils.formatObjectId(self.receiverObjectId)}, params={self.params}, data={self.data}"

pyhausbus-1.0.0/pyhausbus/HausBusUtils.py

@@ -0,0 +1,193 @@
+import logging
+import time
+import traceback
+
+LOGGER = logging.getLogger("pyhausbus")
+
+HOMESERVER_DEVICE_ID:int = 9998
+HOMESERVER_OBJECT_ID:int = (HOMESERVER_DEVICE_ID << 16) + (0 << 8) + 1
+
+UDP_PORT = 5855
+
+def getObjectId(deviceId:int, classId:int, instanceId:int) -> int:
+  return (deviceId << 16) + (classId << 8) + instanceId
+
+def bytesToDWord(data:bytearray, offset) -> int:
+  try:
+    result = 0
+    result += (data[offset[0]] & 0xff)
+    offset[0] += 1
+
+    result += (data[offset[0]] & 0xff) * 256
+    offset[0] += 1
+
+    result += (data[offset[0]] & 0xff) * 65536
+    offset[0] += 1
+
+    result += (data[offset[0]] & 0xff) * 16777216
+    offset[0] += 1
+
+    return result
+  except (Exception) as err:
+    LOGGER.error(err,exc_info=True,stack_info=True)
+    return 0
+
+
+def bytesToWord(data:bytearray, offset) -> int:
+  try:
+    result = 0
+    result += (data[offset[0]] & 0xff)
+    offset[0] += 1
+
+    result += (data[offset[0]] & 0xff) * 256
+    offset[0] += 1
+
+    return result
+  except (Exception) as err:
+    LOGGER.error(err,exc_info=True,stack_info=True)
+    return 0
+
+
+def bytesToInt(data:bytearray, offset) -> int:
+  try:
+    if (len(data)<=offset[0]):
+      return 0
+    result = data[offset[0]] & 0xff
+    offset[0] += 1
+    return result
+  except (Exception) as err:
+    LOGGER.error(err,exc_info=True,stack_info=True)
+    return 0
+
+
+def bytesToString(data:bytearray, offset) -> str:
+  try:
+    result = ""
+    for i in range(offset[0], len(data)):
+      offset[0] += 1
+      if (data[i] == 0):
+        break
+
+      result += chr(data[i])
+    return result
+  except (Exception) as err:
+    LOGGER.error(err,exc_info=True,stack_info=True)
+    return ""
+
+
+def bytesToDebugString(message:bytearray) -> str:
+  result = ""
+  for byte in message:
+    if (result != ""):
+      result = result + ", "
+    result = result + hex(byte)
+  return result
+
+
+def getInstanceId(objectId) -> int:
+  return (objectId) & 0xff
+
+
+def getDeviceId(objectId) -> int:
+  return ((objectId >> 24) & 0xff) * 256 + ((objectId >> 16) & 0xff)
+
+
+def getClassId(objectId) -> int:
+  return (objectId >> 8) & 0xff
+
+
+def formatObjectId(objectId) -> str:
+  result = "[DeviceId: " + str(getDeviceId(objectId))
+  result += ", ClassId: " + str(getClassId(objectId))
+  result += ", Instance: " + str(getInstanceId(objectId)) + "]"
+  return result
+
+
+def getClockIndependMillis():
+  return time.perf_counter() * 1000
+
+
+def setBit(is_set: bool, bit: int, value: int) -> int:
+    if is_set:
+        value |= (1 << bit)
+    else:
+        value &= ~(1 << bit)
+    return value
+
+
+def isBitSet(bit:int, value:int) -> bool:
+  return ((value >> bit) & 1) > 0
+
+
+def bytesToBlob(data:bytearray, offset) -> bytearray:
+  try:
+    result = bytearray(len(data) - offset[0])
+    result[:] = data[offset[0]:]
+    offset[0]=offset[0]+len(data)
+    return result
+  except (Exception) as err:
+    LOGGER.error(err,exc_info=True,stack_info=True)
+    return 0
+
+def dWordToBytes(value: int) -> bytearray:
+  result = bytearray(4)
+  result[0] = value & 0xff
+  result[1] = (value >> 8) & 0xff
+  result[2] = (value >> 16) & 0xff
+  result[3] = (value >> 24) & 0xff
+  return result
+
+
+def addWord(value: int, inOutList):
+  inOutList.append(value & 0xff)
+  inOutList.append((value >> 8) & 0xff)
+
+def addDword(value: int, inOutList):
+  inOutList.append(value & 0xff)
+  inOutList.append((value >> 8) & 0xff)
+  inOutList.append((value >> 16) & 0xff)
+  inOutList.append((value >> 24) & 0xff)
+
+def wordToBytes(value: int) -> bytearray:
+  result = bytearray(2)
+  result[0] = value & 0xff
+  result[1] = (value >> 8) & 0xff
+  return result
+
+def bytesToSInt(data:bytearray, offset) -> int:
+  result = data[offset[0]] & 0xff
+  offset[0]+=1
+  if (result > 127):
+    result -= 256
+  return result
+
+def formatBytes(data:bytearray, offset:int=0, length:int=-1, asHex:bool=True) -> str:
+  if (length==-1):
+    length=len(data)
+
+    if (data == None):
+      return "NULL"
+
+    result=""
+
+    for i in range (offset,length):
+      if (asHex):
+        result+="0x"+hex(data[i])
+      else:
+        result+=data[i] & 0xff
+    return result
+
+def bytesToList(data:bytearray, offset):
+  try:
+    result = bytearray()
+    offsetStart = offset[0]
+    for i in range (offsetStart,len(data),2):
+      key = data[i] & 0xff
+      value = data[i + 1] & 0xff
+      result.append(key)
+      result.append(value)
+      offset[0]+=2
+    return result
+  except (Exception) as err:
+    LOGGER.error(err,exc_info=True,stack_info=True)
+    return bytearray()

pyhausbus-1.0.0/pyhausbus/HomeServer.py

@@ -0,0 +1,68 @@
+from pyhausbus.BusHandler import BusHandler
+from pyhausbus.IBusDataListener import IBusDataListener
+from pyhausbus.de.hausbus.homeassistant.proxy.Controller import Controller
+from pyhausbus.de.hausbus.homeassistant.proxy.controller.params.EIndex import EIndex
+from pyhausbus.de.hausbus.homeassistant.proxy.controller.data.RemoteObjects import (
+    RemoteObjects,
+)
+from pyhausbus.HausBusUtils import LOGGER
+import pyhausbus.de.hausbus.homeassistant.proxy.ProxyFactory as ProxyFactory
+import pyhausbus.HausBusUtils as HausBusUtils
+from pyhausbus.de.hausbus.homeassistant.proxy.controller.data.ModuleId import ModuleId
+import importlib
+import traceback
+import time
+import threading
+from pyhausbus.de.hausbus.homeassistant.proxy.controller.data.EvStarted import EvStarted
+from pyhausbus.ResultWorker import ResultWorker
+
+class HomeServer(IBusDataListener):
+    _instance = None
+    bushandler = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super().__new__(cls, *args, **kwargs)
+        return cls._instance
+
+    def __init__(self):
+        LOGGER.debug("init homeserver")
+        self.bushandler = BusHandler.getInstance()
+        self.bushandler.addBusEventListener(ResultWorker())
+        self.bushandler.addBusEventListener(self)
+
+    def searchDevices(self):
+        controler = Controller(0)
+        controler.getModuleId(EIndex.RUNNING)
+
+    def addBusEventListener(self, listener: IBusDataListener):
+        self.bushandler.addBusEventListener(listener)
+
+    def removeBusEventListener(self, listener: IBusDataListener):
+        self.bushandler.removeBusEventListener(listener)
+
+    def getDeviceInstances(self, senderObjectId: int, remoteObjects: RemoteObjects):
+        deviceId = HausBusUtils.getDeviceId(senderObjectId)
+        objectList = remoteObjects.getObjectList()
+
+        result = []
+        for i in range(0, len(objectList), 2):
+            instanceId = objectList[i]
+            classId = objectList[i + 1]
+            className = ProxyFactory.getBusClassNameForClass(classId)
+            objectId = HausBusUtils.getObjectId(deviceId, classId, instanceId)
+
+            try:
+                module_name, class_name = className.rsplit(".", 1)
+                module = importlib.import_module(className)
+                cls = getattr(module, class_name)
+                obj = cls(objectId)
+                result.append(obj)
+            except Exception as err:
+                LOGGER.error(err,exc_info=True, stack_info=True)
+        return result
+
+    def busDataReceived(self, busDataMessage):
+        """if a device restarts during runtime, we automatically read moduleId"""
+        if isinstance(busDataMessage.getData(), EvStarted):
+            Controller(busDataMessage.getSenderObjectId()).getModuleId(EIndex.RUNNING)

pyhausbus-1.0.0/pyhausbus/IBusDataListener.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+class IBusDataListener(ABC):
+
+    @abstractmethod
+    def busDataReceived(self,busDataMessage):
+        pass

pyhausbus-1.0.0/pyhausbus/Main.py

@@ -0,0 +1,100 @@
+from pyhausbus.HomeServer import HomeServer
+from pyhausbus.ResultWorker import ResultWorker
+from pyhausbus.IBusDataListener import IBusDataListener
+from pyhausbus.de.hausbus.homeassistant.proxy.Controller import Controller
+from pyhausbus.de.hausbus.homeassistant.proxy.Taster import Taster
+from pyhausbus.de.hausbus.homeassistant.proxy.Led import Led
+from pyhausbus.de.hausbus.homeassistant.proxy.Dimmer import Dimmer
+from pyhausbus.de.hausbus.homeassistant.proxy.Schalter import Schalter
+from pyhausbus.de.hausbus.homeassistant.proxy.controller.data.ModuleId import ModuleId
+from pyhausbus.de.hausbus.homeassistant.proxy.controller.data.RemoteObjects import RemoteObjects
+from pyhausbus.de.hausbus.homeassistant.proxy.LogicalButton import LogicalButton
+from pyhausbus.de.hausbus.homeassistant.proxy.controller.params import EIndex
+from pyhausbus.de.hausbus.homeassistant.proxy.taster.data.Configuration import Configuration
+from pyhausbus.de.hausbus.homeassistant.proxy.dimmer.params.EDirection import EDirection
+from pyhausbus.de.hausbus.homeassistant.proxy.dimmer.data.EvOn import EvOn
+from pyhausbus.de.hausbus.homeassistant.proxy.dimmer.data.EvOff import EvOff
+from pyhausbus.de.hausbus.homeassistant.proxy.Feuchtesensor import Feuchtesensor
+import pyhausbus.HausBusUtils
+from pyhausbus.ObjectId import ObjectId
+import time
+
+class Main(IBusDataListener):
+
+  def __init__(self):
+
+    '''
+    Instantiate Homeserver, add as Lister and search Devices
+    Afterwards all devices respond with their moduleId. See method busDataReceived
+    '''
+    self.server = HomeServer()
+    self.server.addBusEventListener(self)
+    '''self.server.searchDevices()'''
+
+    ''' Example how to directly create a feature with given class and instance id'''
+    Dimmer.create(22784, 5).setBrightness(100, 0)
+
+    ''' Example how to directly create a feature with given ObjectId and wait for the result '''
+    taster = Taster(1313542180)
+    ''' Then we call the method'''
+    taster.getConfiguration()
+    ''' And then wait for the Result with a timeout of 2 seconds'''
+    configuration = ResultWorker().waitForResult(2)
+    print("configuration = "+str(configuration))
+
+    self.doTests()
+
+
+
+
+  def busDataReceived(self, busDataMessage):
+    print("got: " + str(busDataMessage.getData()) + " from " + str(ObjectId(busDataMessage.getSenderObjectId())) + " to " + str(ObjectId(busDataMessage.getReceiverObjectId())))
+
+    if (isinstance(busDataMessage.getData(), RemoteObjects)):
+      instances = self.server.getDeviceInstances(busDataMessage.getSenderObjectId(), busDataMessage.getData())
+      for actInstance in instances:
+        print (actInstance)
+
+
+  def doTests(self):
+
+    controller = Controller.create(3359, 1)
+    controller.getConfiguration()
+    print("Controller.configuration = "+str(ResultWorker().waitForResult(2)))
+    controller.getModuleId(EIndex.EIndex.RUNNING)
+    print("Controller.moduleId = "+str(ResultWorker().waitForResult(2)))
+    controller.ping()
+    print("Controller.pong = "+str(ResultWorker().waitForResult(2)))
+
+    dimmer = Dimmer.create(22784, 5)
+    dimmer.getConfiguration()
+    print("Dimmer.configuration = "+str(ResultWorker().waitForResult(2)))
+    dimmer.getStatus()
+    print("Dimmer.status = "+str(ResultWorker().waitForResult(2)))
+    dimmer.start(EDirection.TO_LIGHT)
+    print("Dimmer.evOn = "+str(ResultWorker().waitForEvent(EvOn, dimmer.getObjectId(), 5)))
+    dimmer.start(EDirection.TO_DARK)
+    print("Dimmer.evOff = "+str(ResultWorker().waitForEvent(EvOff, dimmer.getObjectId(), 5)))
+
+    feuchtesensor = Feuchtesensor.create(25661 , 88)
+    feuchtesensor.getConfiguration()
+    print("Feuchtesensor.configuration = "+str(ResultWorker().waitForResult(2)))
+    feuchtesensor.getStatus()
+    print("Feuchtesensor.status = "+str(ResultWorker().waitForResult(2)))
+
+    led = Led.create(20043,54)
+    led.getConfiguration()
+    print("Led.configuration = "+str(ResultWorker().waitForResult(2)))
+    led.getStatus()
+    print("Led.status = "+str(ResultWorker().waitForResult(2)))
+    led.on(50, 5, 0)
+    led.getStatus()
+    print("Led.status = "+str(ResultWorker().waitForResult(2)))
+    time.sleep(2)
+    led.getStatus()
+    print("Led.status = "+str(ResultWorker().waitForResult(2)))
+    time.sleep(3)
+    led.getStatus()
+    print("Led.status = "+str(ResultWorker().waitForResult(2)))
+
+Main()

pyhausbus-1.0.0/pyhausbus/ObjectId.py

@@ -0,0 +1,22 @@
+import pyhausbus.HausBusUtils as HausBusUtils
+
+class ObjectId:
+  objectId:int=0
+
+  def __init__ (self, objectId:int):
+    self.objectId = objectId
+
+  def getValue(self) -> int:
+    return self.objectId
+
+  def getDeviceId(self) -> int:
+    return HausBusUtils.getDeviceId(self.objectId)
+
+  def getClassId(self) -> int:
+    return HausBusUtils.getClassId(self.objectId)
+
+  def getInstanceId(self) -> int:
+    return HausBusUtils.getInstanceId(self.objectId)
+
+  def __str__(self):
+    return f"Object(DeviceId={self.getDeviceId()}, ClassId={self.getClassId()}, InstanceId={self.getInstanceId()} - {hex(self.objectId)} ({self.objectId}))"