pyhausbus 1.0.1__tar.gz → 1.0.3__tar.gz

pyhausbus-1.0.3/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.3/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.1
+Name: pyhausbus
+Version: 1.0.3
+Summary: Python based library for accessing haus-bus.de modules. Inteded to be used in a Home Assistant integration.
+Home-page: https://haus-bus.secure-stores.de/
+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
+Classifier: Programming Language :: Python :: 3.13
+Project-URL: Bug Tracker, https://github.com/hausbus/homeassistant/issues
+Project-URL: Repository, https://github.com/hausbus/homeassistant
+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.3/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.3/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.3/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.3/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.3/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.3/pyhausbus/HausBusUtils.py

@@ -0,0 +1,203 @@
+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.3/pyhausbus/HomeServer.py

@@ -0,0 +1,86 @@
+from pyhausbus.BusHandler import BusHandler
+from pyhausbus.Templates import Templates
+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
+from pyhausbus.de.hausbus.homeassistant.proxy.controller.data.Configuration import Configuration
+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
+    modulesIds = {}
+    configurations = {}
+
+    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()
+        moduleId = self.modulesIds[deviceId];
+        configuration = self.configurations[deviceId];
+
+        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)
+            featureName = Templates.get_instance().get_feature_name_from_template(moduleId.getFirmwareId(), configuration.getFCKE(), classId, instanceId);
+            
+            try:
+                module_name, class_name = className.rsplit(".", 1)
+                module = importlib.import_module(className)
+                cls = getattr(module, class_name)
+                obj = cls(objectId)
+                if featureName!=None:
+                  obj.setName(featureName)
+                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(), ModuleId):
+            self.modulesIds[HausBusUtils.getDeviceId(busDataMessage.getSenderObjectId())]=busDataMessage.getData();
+            Controller(busDataMessage.getSenderObjectId()).getConfiguration()
+
+        if isinstance(busDataMessage.getData(), Configuration):
+            self.configurations[HausBusUtils.getDeviceId(busDataMessage.getSenderObjectId())]=busDataMessage.getData();
+            Controller(busDataMessage.getSenderObjectId()).getRemoteObjects()
+
+        """ if a device restarts during runtime, we automatically read moduleId"""
+        if isinstance(busDataMessage.getData(), EvStarted):
+            Controller(busDataMessage.getSenderObjectId()).getModuleId(EIndex.RUNNING)

pyhausbus-1.0.3/pyhausbus/IBusDataListener.py

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