python-dali 0.10__tar.gz → 0.12__tar.gz

{python-dali-0.10/python_dali.egg-info → python_dali-0.12}/PKG-INFO

@@ -1,25 +1,29 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-dali
-Version: 0.10
+Version: 0.12
 Summary: Interface to DALI lighting systems
 Home-page: https://github.com/sde1000/python-dali
 Author: Stephen Early
 Author-email: steve@assorted.org.uk
-License: LGPL3+
-Platform: UNKNOWN
+License: "LGPL-3.0-or-later"
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
-Provides-Extra: driver-serial
-Provides-Extra: driver-unipi
-Provides-Extra: test
 License-File: COPYING
 License-File: COPYING.LESSER
 License-File: LICENSE
+Provides-Extra: driver-unipi
+Requires-Dist: pyusb; extra == "driver-unipi"
+Requires-Dist: pymodbus; extra == "driver-unipi"
+Provides-Extra: driver-serial
+Requires-Dist: pyserial-asyncio; extra == "driver-serial"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: pyserial-asyncio; extra == "test"
+Dynamic: license-file
 
 python-dali — lighting control interface
 ========================================
@@ -44,7 +48,9 @@ This library has been written with reference to the following documents:
 - IEC 62386-201:2009 (fluorescent lamps)
 - IEC 62386-202:2009 (self-contained emergency lighting)
 - IEC 62386-205:2009 (supply voltage controller for incandescent lamps)
+- IEC 62386-206:2009 (conversion from digital signal into DC voltage)
 - IEC 62386-207:2009 (LED modules)
+- IEC 62386-209:2012 (colour control)
 - IEC 62386-301:2017 (particular requirements for push button input devices)
 - IEC 62386-303:2017 (particular requirements for occupancy sensor input devices)
 
@@ -64,7 +70,7 @@ Interface Alliance`_:
 Python versions supported
 -------------------------
 
-This library currently requires Python version 3.7 or later.
+This library currently requires Python version 3.8 or later.
 
 Stability
 ---------
@@ -108,6 +114,8 @@ Library structure
 
     - ``serial`` - asyncio-based driver for Lunatone LUBA RS232 interfaces
 
+    - ``atxled`` - Driver for ATX LED SERIAL DALI HAT
+
   - ``exceptions`` - DALI related exceptions
 
   - ``frame`` - Forward and backward frames; stable
@@ -150,11 +158,21 @@ Contributors
 
 - Sean Lanigan, Wallace Building Systems Pty Ltd
 
+- Markus Becker
+
+- Jan Kundrát
+
+- Olivier Pieters
+
+- David Russell
+
+- Nikolay Korotkiy
+
 
 Copyright
 ---------
 
-python-dali is Copyright (C) 2013–2022 Stephen Early <steve@assorted.org.uk>
+python-dali is Copyright (C) 2013–2026 Stephen Early <steve@assorted.org.uk>
 and other contributors.
 
 It is distributed under the terms of the GNU Lesser General Public
@@ -172,5 +190,3 @@ not, see `this link`_.
 
 .. _this link: https://www.gnu.org/licenses/
 .. _Digital Illumination Interface Alliance: https://www.dali-alliance.org/dali/data.html
-
-

{python-dali-0.10 → python_dali-0.12}/README.rst

@@ -21,7 +21,9 @@ This library has been written with reference to the following documents:
 - IEC 62386-201:2009 (fluorescent lamps)
 - IEC 62386-202:2009 (self-contained emergency lighting)
 - IEC 62386-205:2009 (supply voltage controller for incandescent lamps)
+- IEC 62386-206:2009 (conversion from digital signal into DC voltage)
 - IEC 62386-207:2009 (LED modules)
+- IEC 62386-209:2012 (colour control)
 - IEC 62386-301:2017 (particular requirements for push button input devices)
 - IEC 62386-303:2017 (particular requirements for occupancy sensor input devices)
 
@@ -41,7 +43,7 @@ Interface Alliance`_:
 Python versions supported
 -------------------------
 
-This library currently requires Python version 3.7 or later.
+This library currently requires Python version 3.8 or later.
 
 Stability
 ---------
@@ -85,6 +87,8 @@ Library structure
 
     - ``serial`` - asyncio-based driver for Lunatone LUBA RS232 interfaces
 
+    - ``atxled`` - Driver for ATX LED SERIAL DALI HAT
+
   - ``exceptions`` - DALI related exceptions
 
   - ``frame`` - Forward and backward frames; stable
@@ -127,11 +131,21 @@ Contributors
 
 - Sean Lanigan, Wallace Building Systems Pty Ltd
 
+- Markus Becker
+
+- Jan Kundrát
+
+- Olivier Pieters
+
+- David Russell
+
+- Nikolay Korotkiy
+
 
 Copyright
 ---------
 
-python-dali is Copyright (C) 2013–2022 Stephen Early <steve@assorted.org.uk>
+python-dali is Copyright (C) 2013–2026 Stephen Early <steve@assorted.org.uk>
 and other contributors.
 
 It is distributed under the terms of the GNU Lesser General Public

{python-dali-0.10 → python_dali-0.12}/dali/device/__init__.py

@@ -7,3 +7,5 @@ part 103 ("General requirements - Control devices") and parts 3xx
 import dali.device.general
 import dali.device.sequences
 import dali.device.pushbutton  # noqa: F401
+import dali.device.occupancy  # noqa: F401
+import dali.device.light  # noqa: F401

{python-dali-0.10 → python_dali-0.12}/dali/device/helpers.py

@@ -127,8 +127,7 @@ class DeviceInstanceTypeMapper:
             if isinstance(rsp, QueryDeviceStatusResponse):
                 # Make sure the status is OK
                 if (
-                    rsp.input_device_error
-                    or rsp.short_address_is_mask
+                    rsp.short_address_is_mask
                     or rsp.reset_state
                 ):
                     continue

{python-dali-0.10 → python_dali-0.12}/dali/device/sequences.py

@@ -14,6 +14,9 @@ from dali.device.general import (
     DTR2,
     EventScheme,
     InstanceEventFilter,
+    QueryResolution,
+    QueryInputValue,
+    QueryInputValueLatch,
     QueryEventFilterH,
     QueryEventFilterL,
     QueryEventFilterM,
@@ -23,6 +26,7 @@ from dali.device.general import (
     SetEventScheme,
 )
 from dali.device.helpers import check_bad_rsp
+from dali.exceptions import DALISequenceError
 
 
 def SetEventSchemes(
@@ -225,3 +229,49 @@ def QueryEventFilters(
         hi = rsp.value
 
     return filter_type(int.from_bytes((lo, md, hi), "little"))
+
+
+def query_input_value(
+    device: DeviceShort,
+    instance: InstanceNumber,
+    resolution: Optional[int] = None
+) -> Generator[Command, Optional[Response], Optional[int]]:
+    """
+    A generator sequence to retrieve full sensor value from a part-103 control device.
+    Use with an appropriate DALI driver instance, through the `run_sequence()`
+    method.
+
+    :param device: A DeviceShort address to target
+    :param instance: An InstanceNumber to target
+    :param resolution: Number of valid bits that the device provides
+    """
+    # Although the proper types are expected, ints are common enough for
+    # addresses and their meaning is unambiguous in this context
+    if isinstance(device, int):
+        device = DeviceShort(device)
+    if isinstance(instance, int):
+        instance = InstanceNumber(instance)
+
+    if resolution is None:
+        resolution = yield QueryResolution(device, instance)
+        if check_bad_rsp(resolution):
+            raise DALISequenceError("query_input_value: QueryResolution failed")
+        resolution = resolution.value
+
+    value = yield QueryInputValue(device, instance)
+    if check_bad_rsp(value):
+        raise DALISequenceError("query_input_value: QueryInputValue failed")
+    value = value.value
+    while resolution > 8:
+        resolution -= 8
+        value <<= 8
+        chunk = yield QueryInputValueLatch(device, instance)
+        if check_bad_rsp(chunk):
+            raise DALISequenceError("query_input_value: QueryInputValueLatch failed")
+        value += chunk.value
+
+    if resolution > 0:
+        # Strip the repeated trailing bytes as per IEC 62386-103:2014, part 9.7.2
+        value >>= 8 - resolution
+
+    return value

python_dali-0.12/dali/driver/atxled.py

@@ -0,0 +1,154 @@
+from dali.command import Command
+from dali.driver.base import SyncDALIDriver, DALIDriver
+from dali.frame import BackwardFrame
+import logging
+import sys
+
+import serial
+import threading
+import time
+
+DALI_PACKET_SIZE = {"j": 8, "h": 16, "l": 24, "m": 25}
+DALI_PACKET_PREFIX = {v: k for k, v in DALI_PACKET_SIZE.items()}
+
+
+class DaliHatSerialDriver(DALIDriver):
+    """Driver for communicating with DALI devices over a serial connection."""
+
+    def __init__(self, port="/dev/ttyS0", LOG=None):
+        """Initialize the serial connection to the DALI interface."""
+        self.port = port
+        self.lock = threading.RLock()
+        self.buffer = []
+        if not LOG:
+            self.LOG = logging.getLogger("AtxLedDaliDriver")
+            handler = logging.StreamHandler(sys.stdout)
+            self.LOG.addHandler(handler)
+        else:
+            self.LOG = LOG
+        try:
+            self.conn = serial.Serial(
+                port=self.port,
+                baudrate=19200,
+                parity=serial.PARITY_NONE,
+                stopbits=serial.STOPBITS_ONE,
+                bytesize=serial.EIGHTBITS,
+                timeout=0.2,
+            )
+        except Exception as e:
+            self.LOG.exception("Could not open serial connection: %s", e)
+            self.conn = None
+
+    def read_line(self):
+        """Read the next line from the buffer, refilling the buffer if necessary."""
+        with self.lock:
+            while not self.buffer:
+                line = self.conn.read_until(b"\n").decode("ascii")
+                if not line:
+                    return ""
+                self.buffer.append(line)
+            return self.buffer.pop(0)
+
+    def construct(self, command):
+        """Construct a DALI command to be sent over the serial connection."""
+        assert isinstance(command, Command)
+        f = command.frame
+        packet_size = len(f)
+        prefix = DALI_PACKET_PREFIX[packet_size]
+        if command.sendtwice and packet_size == 16:
+            prefix = "t"
+        data = "".join(["{:02X}".format(byte) for byte in f.pack])
+        command_str = (f"{prefix}{data}\n").encode("ascii")
+        return command_str
+
+    def extract(self, data):
+        """Parse the response from the serial device and return the corresponding frame."""
+        if data.startswith("J"):
+            try:
+                data = int(data[1:], 16)
+                return BackwardFrame(data)
+            except ValueError as e:
+                self.LOG.error(f"Failed to parse response '{data}': {e}")
+        return None
+
+    def close(self):
+        """Close the serial connection."""
+        if self.conn:
+            self.conn.close()
+
+
+class SyncDaliHatDriver(DaliHatSerialDriver, SyncDALIDriver):
+    """Synchronous DALI driver."""
+
+    def send(self, command: Command):
+        """Send a command to the DALI interface and wait for a response."""
+        with self.lock:
+            lines = []
+            last_resp = None
+            send_twice = command.sendtwice
+            cmd = self.construct(command)
+            self.LOG.debug("command string sent: %r", cmd)
+            self.conn.write(cmd)
+            REPS = 5
+            i = 0
+            already_resent = False
+            resent_times = 0
+            resp = None
+            while i < REPS:
+                i += 1
+                resp = self.read_line()
+                self.LOG.debug("raw response received: %r", resp)
+                resend = False
+                if cmd[:3] not in ["hB1", "hB3", "hB5"]:
+                    if resp and resp[0] in {"N", "J"}:
+                        if send_twice:
+                            if last_resp:
+                                if last_resp == resp:
+                                    resp = self.extract(resp)
+                                    break
+                                resend = True
+                                last_resp = None
+                            else:
+                                last_resp = resp
+                        else:
+                            resp = self.extract(resp)
+                            break
+                    elif resp and resp[0] in {"X", "Z", ""}:
+                        time.sleep(0.1)
+                        collision_bytes = None
+                        while collision_bytes != "":
+                            collision_bytes = self.read_line()
+                        if resp[0] == "X":
+                            break
+                        self.LOG.info(
+                            "got conflict (%s) sending %r, sending again", resp, cmd
+                        )
+                        last_resp = None
+                        resend = True
+                    elif resp:
+                        lines.append(resp)
+
+                    resp = None
+                    if resend and not already_resent:
+                        self.conn.write((cmd).encode("ascii"))
+                        REPS += 1 + send_twice
+                        already_resent = True
+                else:
+                    if resp and resp[0] == "N":
+                        resp = self.extract(resp)
+                        break
+                    elif resp and resp[0] in {"X", "Z", ""}:
+                        time.sleep(0.1)
+                        collision_bytes = None
+                        while collision_bytes != "":
+                            collision_bytes = self.read_line()
+                    elif resp:
+                        last_resp = None
+                        resend = True
+                if resend and resent_times < 5:
+                    self.conn.write(cmd.encode("ascii"))
+                    REPS += 1 + send_twice
+                    resent_times += 1
+            if command.is_query:
+                return command.response(resp)
+            return resp

{python-dali-0.10 → python_dali-0.12}/dali/driver/base.py

@@ -1,7 +1,3 @@
-import threading
-import usb
-
-
 ###############################################################################
 # driver contracts
 ###############################################################################
@@ -124,113 +120,3 @@ class Listener(Backend):
         """
         raise NotImplementedError(
             'Abstract ``Listener`` does not implement ``listen``')
-
-
-###############################################################################
-# USB backends
-###############################################################################
-
-class USBBackend(Backend):
-    """Backend implementation for communicating with USB devices.
-    """
-
-    def __init__(self, vendor, product, bus=None,
-                 port_numbers=None, interface=0):
-        self._device = None
-        # lookup devices by vendor and product
-        devices = [dev for dev in usb.core.find(
-            find_all=True,
-            idVendor=vendor,
-            idProduct=product
-        )]
-        # use first device if bus or port_numers not defined
-        if bus is None or port_numbers is None:
-            self._device = devices[0]
-        else:
-            for dev in devices:
-                if dev.bus == bus and dev.port_numbers == port_numbers:
-                    self._device = dev
-                    break
-        # if queried device not found, raise
-        if not self._device:
-            raise usb.core.USBError('Device not found')
-        # detach kernel driver if necessary
-        if self._device.is_kernel_driver_active(interface) is True:
-            self._device.detach_kernel_driver(interface)
-        # set device configuration
-        self._device.set_configuration()
-        # claim interface
-        usb.util.claim_interface(self._device, interface)
-        # get active configuration
-        cfg = self._device.get_active_configuration()
-        intf = cfg[(0, 0)]
-        # get write end point
-        def match_ep_out(e):
-            return usb.util.endpoint_direction(e.bEndpointAddress) == \
-                   usb.util.ENDPOINT_OUT
-        self._ep_write = usb.util.find_descriptor(
-            intf, custom_match=match_ep_out)
-        # get read end point
-        def match_ep_in(e):
-            return usb.util.endpoint_direction(e.bEndpointAddress) == \
-                   usb.util.ENDPOINT_IN
-        self._ep_read = usb.util.find_descriptor(
-            intf, custom_match=match_ep_in)
-
-    def read(self, timeout=None):
-        """Read data from USB device.
-        """
-        return self._ep_read.read(self._ep_read.wMaxPacketSize, timeout=timeout)
-
-    def write(self, data):
-        """Write data to USB device.
-        """
-        return self._ep_write.write(data)
-
-    def close(self):
-        """Close connection to USB device.
-        """
-        usb.util.dispose_resources(self._device)
-
-
-class USBListener(USBBackend, Listener):
-    """Listener implementation for communicating with USB devices.
-    """
-
-    def __init__(self, driver, vendor, product, bus=None,
-                 port_numbers=None, interface=0):
-        super(USBListener, self).__init__(
-            vendor,
-            product,
-            bus=bus,
-            port_numbers=port_numbers,
-            interface=interface
-        )
-        self.driver = driver
-        # flag whether actually disconnecting from device
-        self._disconnecting = False
-        # event to stop listening
-        self._stop_listening = threading.Event()
-        # create and start listener thread
-        self._listener = threading.Thread(target=self.listen)
-        self._listener.start()
-
-    def listen(self):
-        """Poll data from USB device.
-        """
-        while not self._stop_listening.is_set():
-            try:
-                self.driver.receive(self.read())
-            except usb.core.USBError as e:
-                # read timeout
-                if e.errno == 110:
-                    continue
-                if not self._disconnecting:
-                    self.close()
-
-    def close(self):
-        """Close connection to USB device.
-        """
-        self._disconnecting = True
-        self._stop_listening.set()
-        super(USBListener, self).close()