pyhausbus 1.0.1__py2.py3-none-any.whl → 1.0.3__py2.py3-none-any.whl

pyhausbus/Main.py

@@ -1,100 +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()
+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/ObjectId.py

@@ -1,22 +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}))"
+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}))"

pyhausbus/ResultWorker.py

@@ -1,53 +1,53 @@
-from pyhausbus.HausBusUtils import LOGGER
-import time
-import threading
-
-
-class ResultWorker:
-  _instance = None
-  _resultClass = None
-  _resultSenderObjectId = 0
-  _resultObject = None
-  _condition = threading.Condition()
-
-  def __new__(cls, *args, **kwargs):
-    if not cls._instance:
-      cls._instance = super().__new__(cls, *args, **kwargs)
-    return cls._instance
-
-  def _setResultInfo(self, resultClass, resultSenderObjectId:int):
-    '''print("resultInfo " + str(resultClass) + ", ID " + str(resultSenderObjectId))'''
-    self._resultClass = resultClass
-    self._resultSenderObjectId = resultSenderObjectId
-    self._resultObject=None
-
-  def waitForResult(self, timeoutInSeconds:int):
-    start_time = time.time()
-    end_time = start_time + timeoutInSeconds
-
-    with self._condition:
-      while self._resultObject == None and time.time() < end_time:
-        self._condition.wait(1)
-
-    return self._resultObject
-
-  def waitForEvent(self, event, eventSenderObjectId, timeoutInSeconds:int):
-    self._resultClass = event
-    self._resultSenderObjectId = eventSenderObjectId
-    self._resultObject=None
-
-    start_time = time.time()
-    end_time = start_time + timeoutInSeconds
-
-    with self._condition:
-      while self._resultObject == None and time.time() < end_time:
-        self._condition.wait(1)
-
-    return self._resultObject
-
-  def busDataReceived(self, busDataMessage):
-    '''print("got "+str(busDataMessage))'''
-    if (self._resultClass != None and busDataMessage.getSenderObjectId()==self._resultSenderObjectId and isinstance(busDataMessage.getData(), self._resultClass)):
-      with self._condition:
-        self._resultObject = busDataMessage.getData()
-        self._condition.notify()
+from pyhausbus.HausBusUtils import LOGGER
+import time
+import threading
+
+
+class ResultWorker:
+  _instance = None
+  _resultClass = None
+  _resultSenderObjectId = 0
+  _resultObject = None
+  _condition = threading.Condition()
+
+  def __new__(cls, *args, **kwargs):
+    if not cls._instance:
+      cls._instance = super().__new__(cls, *args, **kwargs)
+    return cls._instance
+
+  def _setResultInfo(self, resultClass, resultSenderObjectId:int):
+    '''print("resultInfo " + str(resultClass) + ", ID " + str(resultSenderObjectId))'''
+    self._resultClass = resultClass
+    self._resultSenderObjectId = resultSenderObjectId
+    self._resultObject=None
+
+  def waitForResult(self, timeoutInSeconds:int):
+    start_time = time.time()
+    end_time = start_time + timeoutInSeconds
+
+    with self._condition:
+      while self._resultObject == None and time.time() < end_time:
+        self._condition.wait(1)
+
+    return self._resultObject
+
+  def waitForEvent(self, event, eventSenderObjectId, timeoutInSeconds:int):
+    self._resultClass = event
+    self._resultSenderObjectId = eventSenderObjectId
+    self._resultObject=None
+
+    start_time = time.time()
+    end_time = start_time + timeoutInSeconds
+
+    with self._condition:
+      while self._resultObject == None and time.time() < end_time:
+        self._condition.wait(1)
+
+    return self._resultObject
+
+  def busDataReceived(self, busDataMessage):
+    '''print("got "+str(busDataMessage))'''
+    if (self._resultClass != None and busDataMessage.getSenderObjectId()==self._resultSenderObjectId and isinstance(busDataMessage.getData(), self._resultClass)):
+      with self._condition:
+        self._resultObject = busDataMessage.getData()
+        self._condition.notify()

pyhausbus/Templates.py

@@ -0,0 +1,140 @@
+import os
+from collections import defaultdict
+from typing import List, Dict, Optional
+from pyhausbus.de.hausbus.homeassistant.proxy.controller.params.EFirmwareId import EFirmwareId
+
+def load_file(path: str) -> list[str]:
+    try:
+        with open(path, "r", encoding="latin1") as file:
+            return [line.strip() for line in file if line.strip()]
+    except FileNotFoundError:
+        print(f"Datei nicht gefunden: {path}")
+        return []
+    except Exception as e:
+        print(f"Fehler beim Laden der Datei {path}: {e}")
+        return []
+
+class Templates:
+    template_root_dir = "pyhausbus/templates/"
+    filter_non_existing = True
+    _instance = None
+    class_mappings: Dict[str, str] = {}
+
+    def __init__(self):
+        self.module_types: Dict['ModuleType', str] = {}
+        self.feature_names: Dict['ModuleType', List['FeatureEntry']] = {}
+
+        try:
+            lines = load_file(self.template_root_dir + "deviceTypes.def")
+            for line in lines:
+                tokens = line.split(",")
+                firmware_id = EFirmwareId.value_of(tokens[0])
+                fcke = int(tokens[1].replace("0x", ""), 16)
+                name = tokens[2]
+                self.module_types[ModuleType(firmware_id, fcke)] = name
+
+
+            root_dir = self.template_root_dir
+            if not os.path.exists(root_dir):
+                root_dir = "../JavaLib/" + self.template_root_dir
+
+            for act_file in os.listdir(root_dir):
+                if act_file.endswith(".tpl"):
+                    tokens = act_file.split("_")
+                    firmware_id = EFirmwareId.value_of(tokens[0])
+                    fcke = int(tokens[1], 16)
+                    features = []
+                    self.feature_names[ModuleType(firmware_id, fcke)] = features
+
+                    lines = load_file(os.path.join(root_dir, act_file))
+                    for line in lines:
+                        if line.strip():
+                            features.append(FeatureEntry(line))
+
+            '''for module_type, features in self.feature_names.items():
+              print(module_type)
+              for entry in features:
+                print(entry)
+              
+            quit()'''
+
+            lines = load_file(self.template_root_dir + "classMapping.def")
+            if lines:
+                for line in lines:
+                    tokens = line.split(",")
+                    orig_name = tokens[0]
+                    mapped_name = tokens[1]
+                    Templates.class_mappings[orig_name] = mapped_name
+
+        except Exception as e:
+            print(f"Fehler beim Initialisieren der Templates: {e}")
+
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            cls._instance = Templates()
+        return cls._instance
+
+    def get_feature_name_from_template(self, firmware_id, fcke, class_id, instance_id) -> Optional[str]:
+        if fcke != -1:
+            ''' print("get_feature_name_from_template firmware_id = ",firmware_id," fcke = ",fcke," class_id = ",class_id," instance_id = ",instance_id)'''
+            features = self.get_features(firmware_id, fcke)
+
+            if features:
+                for entry in features:
+                    if entry.suits(class_id, instance_id):
+                        return entry.name
+        return None
+
+    def getModuleName(self, firmwareId: EFirmwareId, fcke: int):
+        for entry in self.module_types:
+          if entry.suits(firmwareId, fcke):
+            return entry.name
+        return None
+    
+    def get_features(self, firmware_id, fcke) -> Optional[List['FeatureEntry']]:
+        for module_type, features in self.feature_names.items():
+            if module_type.suits(firmware_id, fcke):
+                return list(features)
+        return None
+
+
+class FeatureEntry:
+    def __init__(self, line: str):
+        tokens = line.split(",")
+        self.class_id = int(tokens[0])
+        self.instance_id = int(tokens[1])
+        self.name = tokens[2]
+        self.loxone_aktor_type = tokens[3] if len(tokens) > 3 else ""
+
+    def suits(self, class_id: int, instance_id: int) -> bool:
+        return self.class_id == class_id and self.instance_id == instance_id
+
+    def __str__(self):
+        return f"FeatureEntry(classId={self.class_id}, instanceId={self.instance_id}, name='{self.name}', loxoneAktorType='{self.loxone_aktor_type}')"
+
+
+class ModuleType:
+    def __init__(self, firmware_id, fcke):
+        self.firmware_id = firmware_id
+        self.fcke = fcke
+
+    def suits(self, check_firmware_id, check_fcke) -> bool:
+        if check_fcke != self.fcke:
+            return False
+        if check_firmware_id == self.firmware_id:
+            return True
+        if str(check_firmware_id).startswith("HB") and str(self.firmware_id).startswith("HB"):
+            return True
+        return False
+
+    def __eq__(self, other):
+        if not isinstance(other, ModuleType):
+            return False
+        return self.firmware_id == other.firmware_id and self.fcke == other.fcke
+
+    def __hash__(self):
+        return hash((self.firmware_id, self.fcke))
+
+    def __str__(self):
+        return f"ModuleType(firmwareId={self.firmware_id}, fcke={self.fcke})"

pyhausbus/UdpReceiveWorker.py

@@ -1,73 +1,73 @@
-import socket
-import threading
-import traceback
-from pyhausbus.HausBusUtils import *
-from pyhausbus.de.hausbus.homeassistant.proxy import *
-import time
-
-BROADCAST_SEND_IP = "192.255.255.255"
-BROADCAST_RECEIVE_IP = "0.0.0.0"
-BUFFER_SIZE  = 10000
-
-class UdpReceiveWorker:
-  UDP_GATEWAY = "#UDP#"
-
-  def __init__(self, func):
-    LOGGER.debug("init UdpReceiveWorker")
-    self.func = func
-
-  def startWorker(self):
-    LOGGER.debug("starting udp receive worker")
-    t = threading.Thread(target=self.runable)
-    t.start()
-
-  def runable(self):
-    while(True):
-      try:
-        UDPServerSocket = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
-        UDPServerSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        UDPServerSocket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
-        UDPServerSocket.bind((BROADCAST_RECEIVE_IP, UDP_PORT))
-        LOGGER.debug("UDP server up and listening")
-
-        while(True):
-          bytesAddressPair = UDPServerSocket.recvfrom(BUFFER_SIZE)
-          message = bytesAddressPair[0]
-          address = bytesAddressPair[1]
-          LOGGER.debug("Message from Client "+format(address)+": "+bytesToDebugString(message))
-
-
-          if (len(message) == 0):
-            LOGGER.debug("got empty message")
-            continue
-
-          if (message[0] != 0xef | message[1] != 0xef):
-            LOGGER.debug("invalid header")
-            continue
-
-          if (len(message) < 15):
-            LOGGER.debug("message size " + len(message) + " is too short")
-            continue
-
-          # 2 = Kontrollbyte 3 = MessageCounter
-          offset = [4]
-          senderObjectId = bytesToDWord(message, offset)
-          LOGGER.debug("senderObjectId = "+str(senderObjectId))
-
-          receiverObjectId = bytesToDWord(message, offset)
-          LOGGER.debug("receiverObjectId = "+str(receiverObjectId))
-
-          dataLength = bytesToWord(message, offset)
-          if (len(message) < 14 + dataLength):
-            LOGGER.debug("message size " + str(len(message)) + " is too short for data length " + str(dataLength) + ": " + bytesToDebugString(message))
-            dataLength = len(message) - 14
-            # continue
-          functionId = bytesToInt(message, offset)
-          functionData = message[15:]
-
-          LOGGER.debug("functionId " + str(functionId) + ", functionData " + bytesToDebugString(functionData))
-
-          self.func(senderObjectId, receiverObjectId, functionId, functionData, self.UDP_GATEWAY, False)
-      except (Exception) as err:
-        LOGGER.error(err,exc_info=True,stack_info=True)
-        time.sleep(5)
+import socket
+import threading
+import traceback
+from pyhausbus.HausBusUtils import *
+from pyhausbus.de.hausbus.homeassistant.proxy import *
+import time
+
+BROADCAST_SEND_IP = "192.255.255.255"
+BROADCAST_RECEIVE_IP = "0.0.0.0"
+BUFFER_SIZE  = 10000
+
+class UdpReceiveWorker:
+  UDP_GATEWAY = "#UDP#"
+
+  def __init__(self, func):
+    LOGGER.debug("init UdpReceiveWorker")
+    self.func = func
+
+  def startWorker(self):
+    LOGGER.debug("starting udp receive worker")
+    t = threading.Thread(target=self.runable)
+    t.start()
+
+  def runable(self):
+    while(True):
+      try:
+        UDPServerSocket = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
+        UDPServerSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        UDPServerSocket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        UDPServerSocket.bind((BROADCAST_RECEIVE_IP, UDP_PORT))
+        LOGGER.debug("UDP server up and listening")
+
+        while(True):
+          bytesAddressPair = UDPServerSocket.recvfrom(BUFFER_SIZE)
+          message = bytesAddressPair[0]
+          address = bytesAddressPair[1]
+          LOGGER.debug("Message from Client "+format(address)+": "+bytesToDebugString(message))
+
+
+          if (len(message) == 0):
+            LOGGER.debug("got empty message")
+            continue
+
+          if (message[0] != 0xef | message[1] != 0xef):
+            LOGGER.debug("invalid header")
+            continue
+
+          if (len(message) < 15):
+            LOGGER.debug("message size " + len(message) + " is too short")
+            continue
+
+          # 2 = Kontrollbyte 3 = MessageCounter
+          offset = [4]
+          senderObjectId = bytesToDWord(message, offset)
+          LOGGER.debug("senderObjectId = "+str(senderObjectId))
+
+          receiverObjectId = bytesToDWord(message, offset)
+          LOGGER.debug("receiverObjectId = "+str(receiverObjectId))
+
+          dataLength = bytesToWord(message, offset)
+          if (len(message) < 14 + dataLength):
+            LOGGER.debug("message size " + str(len(message)) + " is too short for data length " + str(dataLength) + ": " + bytesToDebugString(message))
+            dataLength = len(message) - 14
+            # continue
+          functionId = bytesToInt(message, offset)
+          functionData = message[15:]
+
+          LOGGER.debug("functionId " + str(functionId) + ", functionData " + bytesToDebugString(functionData))
+
+          self.func(senderObjectId, receiverObjectId, functionId, functionData, self.UDP_GATEWAY, False)
+      except (Exception) as err:
+        LOGGER.error(err,exc_info=True,stack_info=True)
+        time.sleep(5)