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

{python-dali-0.11/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.11
+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
 ---------
@@ -160,11 +166,13 @@ Contributors
 
 - David Russell
 
+- Nikolay Korotkiy
+
 
 Copyright
 ---------
 
-python-dali is Copyright (C) 2013–2024 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
@@ -182,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.11 → 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
 ---------
@@ -137,11 +139,13 @@ Contributors
 
 - David Russell
 
+- Nikolay Korotkiy
+
 
 Copyright
 ---------
 
-python-dali is Copyright (C) 2013–2024 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.11 → 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()

{python-dali-0.11 → python_dali-0.12}/dali/driver/hid.py

@@ -293,6 +293,8 @@ class tridonic(hid):
     # Commands sent to the interface
     # cmd, seq, ctrl, mode, frame (4 bytes), dtr, prio, devtype
     _cmdtmpl = struct.Struct(">4B4s3B53x")
+    # length of the "useful part", without the trailing padding
+    _cmdtmpl_useful_size = _cmdtmpl.size - 53
 
     # _CMD send in byte 0
     _CMD_INIT = 0x01
@@ -332,6 +334,8 @@ class tridonic(hid):
     # Responses received from the interface
     # Decodes to mode, response type, frame, interval, seq
     _resptmpl = struct.Struct(">BB4sHB55x")
+    # length of the "useful part", without the trailing padding
+    _resptmpl_useful_size = _resptmpl.size - 55
     _MODE_INFO = 0x01 # Response to an init command
     _MODE_OBSERVE = 0x11 # Other traffic observed on the bus
     _MODE_RESPONSE = 0x12 # Response to a send command
@@ -384,9 +388,13 @@ class tridonic(hid):
         self._bus_watch_data_available = asyncio.Event()
         self._bus_watch_data = []
 
+    def _raw_write(self, buf: bytes):
+        self._log.debug(f"_raw_write: {_hex(buf[0:self._cmdtmpl_useful_size])}")
+        os.write(self._f, buf)
+
     def _initialise_device(self):
         # Read firmware version; pick up the reply in _handle_read
-        os.write(self._f, self._cmd(
+        self._raw_write(self._cmd(
             tridonic._CMD_INIT, tridonic._CMD_INIT_READVERSION))
 
     async def _power_supply(self, supply_on):
@@ -396,7 +404,7 @@ class tridonic(hid):
                 self._POWER_SUPPLY_ON if supply_on else self._POWER_SUPPLY_OFF)
 
             try:
-                os.write(self._f, data)
+                self._raw_write(data)
             except OSError:
                 # The device has failed.  Disconnect, schedule a
                 # reconnection, and report this command as failed.
@@ -421,7 +429,7 @@ class tridonic(hid):
         await self.connected.wait()
         async with self._command_semaphore:
             seq = next(self._cmd_seq)
-            self._log.debug("Sending with seq %x", seq)
+            self._log.debug(f"Sending with {seq=:02x}")
             event = asyncio.Event()
             messages = []
             # If seq is in self._outstanding this means we've wrapped
@@ -435,7 +443,7 @@ class tridonic(hid):
                 mode=self._command_mode(frame),
                 frame=frame.pack_len(4))
             try:
-                os.write(self._f, data)
+                self._raw_write(data)
             except OSError:
                 # The device has failed.  Disconnect, schedule a
                 # reconnection, and report this command as failed.
@@ -446,11 +454,17 @@ class tridonic(hid):
             outstanding_transmissions = 2 if command.sendtwice else 1
             response = None
             while outstanding_transmissions or response is None:
-                self._log.debug(f"waiting for {outstanding_transmissions=} "
-                                "{response=}")
+                self._log.debug(f"_send_raw waiting for {outstanding_transmissions=} "
+                                f"{response=!s}")
                 if len(messages) == 0:
-                    await event.wait()
-                    event.clear()
+                    try:
+                        await asyncio.wait_for(event.wait(), timeout=0.2)
+                    except TimeoutError:
+                        self._log.error(f"_send_raw timed out {seq=:02x}, faking an error response")
+                        response = dali.frame.BackwardFrameError(255)
+                        break
+                    finally:
+                        event.clear()
                 message = messages.pop(0)
                 if message == "fail":
                     # The device has gone away, possibly in the middle
@@ -461,11 +475,12 @@ class tridonic(hid):
                 # The message mode is guaranteed to be _MODE_RESPONSE
                 mode, rtype, frame, interval, seq = self._resptmpl.unpack(
                     message)
-                self._log.debug(f"message mode={mode:02x} rtype={rtype:02x} frame={frame} interval={interval:04x} seq={seq:02x}")
+                self._log.debug(f"_send_raw got message: {mode=:02x} {rtype=:02x} frame={_hex(frame)} {interval=:04x} {seq=:02x}")
                 if rtype in (self._RESPONSE_FRAME_DALI16,
                              self._RESPONSE_FRAME_DALI24):
                     # XXX check the frame contents?
                     outstanding_transmissions -= 1
+                    self._log.debug(f"_send_raw rtype DALI16 or DALI24, new {outstanding_transmissions=}")
                 elif rtype == self._RESPONSE_FRAME_DALI8:
                     response = dali.frame.BackwardFrame(frame)
                 elif rtype == self._RESPONSE_INFO \
@@ -474,7 +489,8 @@ class tridonic(hid):
                 elif rtype == self._RESPONSE_NO_FRAME:
                     response = "no"
                 else:
-                    self._log.debug(f"didn't understand {rtype=}")
+                    self._log.debug(f"didn't understand {rtype=:02x}")
+            self._log.debug(f"_send_raw finished {seq=:02x}")
             del self._outstanding[seq], event, messages
             if command.response:
                 # Construct response and return it
@@ -498,13 +514,13 @@ class tridonic(hid):
             # Wait for data
             if len(self._bus_watch_data) == 0:
                 if current_command:
-                    self._log.debug("Bus watch waiting with timeout")
+                    self._log.debug("bus_watch waiting with timeout")
                     try:
                         await asyncio.wait_for(self._bus_watch_data_available.wait(), 0.2)
                     except asyncio.TimeoutError:
                         pass
                 else:
-                    self._log.debug("Bus watch waiting for data, no timeout")
+                    self._log.debug("bus_watch waiting for data, no timeout")
                     await self._bus_watch_data_available.wait()
                 self._bus_watch_data_available.clear()
 
@@ -515,10 +531,10 @@ class tridonic(hid):
             else:
                 timeout = False
                 message = self._bus_watch_data.pop(0)
-                self._log.debug("bus_watch message %s", _hex(message[0:9]))
+                self._log.debug("bus_watch message %s", _hex(message[0:self._resptmpl_useful_size]))
                 origin, rtype, raw_frame, interval, seq = self._resptmpl.unpack(message)
                 if origin not in (self._MODE_OBSERVE, self._MODE_RESPONSE):
-                    self._log.debug("bus_watch: unexpected packet mode, ignoring")
+                    self._log.warning("bus_watch: unexpected packet mode, ignoring")
                     continue
                 if rtype == self._RESPONSE_FRAME_DALI16:
                     frame = dali.frame.ForwardFrame(16, raw_frame)
@@ -545,7 +561,7 @@ class tridonic(hid):
                     # We are waiting for a repeat of the command
                     if timeout:
                         # We didn't get it: report a failed command
-                        self._log.debug("Failed sendtwice command: %s", current_command)
+                        self._log.warning("Failed sendtwice command: %s", current_command)
                         self.bus_traffic._invoke(current_command, None, True)
                         current_command = None
                         continue
@@ -557,18 +573,23 @@ class tridonic(hid):
                             current_command = None
                             continue
                         else:
-                            self._log.debug("Failed config command (second frame didn't match): %s", current_command)
+                            self._log.warning("Failed config command (second frame didn't match): %s", current_command)
                             self.bus_traffic._invoke(current_command, None, True)
                             current_command = None
                             # Fall through to continue processing frame
                     elif isinstance(frame, dali.frame.BackwardFrame):
                         # Error: config commands don't get backward frames.
-                        self._log.debug("Failed config command %s with backward frame",
+                        self._log.error("Failed config command %s with backward frame",
                                         current_command)
                         self.bus_traffic._invoke(current_command, None, True)
                         current_command = None
+                    elif frame == "no":
+                        self._log.warning("No frame in response to a sendtwice command: %s", current_command)
+                        self.bus_traffic._invoke(current_command, None, True)
+                        current_command = None
+                        continue
                     else:
-                        self._log.debug("Unexpected response waiting for retransmit of config command")
+                        self._log.error("Unexpected response waiting for retransmit of config command, frame = %s", frame)
                 elif current_command.response:
                     # We are waiting for a response
                     if timeout or frame == "no":
@@ -620,13 +641,13 @@ class tridonic(hid):
             # self._log.debug("End of loop")
 
     def _handle_read(self, data):
-        self._log.debug("_handle_read %s", _hex(data[0:9]))
+        self._log.debug("_handle_read %s", _hex(data[0:self._resptmpl_useful_size]))
         if data[0] == self._MODE_INFO:
             # Response to initialisation command
             if not self.firmware_version:
                 self.firmware_version = f"{data[3]}.{data[4]}"
                 # Now read the serial number
-                os.write(self._f, self._cmd(
+                self._raw_write(self._cmd(
                     tridonic._CMD_INIT, tridonic._CMD_INIT_READSERIAL))
             elif not self.serial:
                 self.serial = _hex(data[1:5])
@@ -644,17 +665,20 @@ class tridonic(hid):
             self._bus_watch_data.append(data)
             self._bus_watch_data_available.set()
             seq = data[8]
-            # The Tridonic DALI USB has a firmware bug.  When it
-            # observes a frame on the bus, not generated by itself,
-            # that matches the most recent frame it transmitted, it
-            # reports it as if it had transmitted it itself.  We
-            # ignore this - the sequence number will have been removed
-            # from self._outstanding.
             if seq in self._outstanding:
+                self._log.debug(f"_handle_read: signaling for {seq=:02x}")
                 event, messages = self._outstanding[seq]
                 messages.append(data)
                 event.set()
                 del event, messages
+            else:
+                # The Tridonic DALI USB has a firmware bug.  When it
+                # observes a frame on the bus, not generated by itself,
+                # that matches the most recent frame it transmitted, it
+                # reports it as if it had transmitted it itself.  We
+                # ignore this - the sequence number will have been removed
+                # from self._outstanding.
+                self._log.debug(f"_handle_read: nothing to do for {seq=:02x}")
 
         else:
             self._log.debug("Unknown response mode %x", data[0])
@@ -717,7 +741,7 @@ class hasseb(hid):
         async with self._command_lock:
             times = 2 if command.sendtwice else 1
             for rep in range(times):
-                os.write(self._f, frame.pack_len(2))
+                self._raw_write(frame.pack_len(2))
             # Earlier commands may have left a response available that
             # we need to ignore.  We're only interested in responses
             # that become available in the future.

{python-dali-0.11 → python_dali-0.12}/dali/driver/serial.py

@@ -590,13 +590,29 @@ class DriverLubaRs232(DriverSerialBase):
             async with self._tx_lock:
                 _LOG.debug("Sending LUBA device settings")
                 mode_settings = 0b00000000
+                # 7: 1 = activates the DALI ping
+                # 6: 1 = Deactivates sending of DALI frames during "Initialize" mode
+                # 5: 1 = Deactivates sending of DALI frames during "Quiescent" mode
+                # 4..0: Reserved
                 event_settings = 0b00010010
+                # 7: 1 = deactivates all events
+                # 6: 1 = deactivates events for successfully sending a DALI frame
+                # 5: 1 = deactivates events for receiving a DALI frame
+                # 4: 1 = deactivate events for the send-buffer (full/empty)
+                # 3: 1 = deactivates including the tick in events
+                # 2: 1 = deactivates including the line number in events
+                # 1: 1 = Deactivates events for macros
+                # 0: reserved
+                hardware_settings = 0b00000000
+                # 7: 1 = turn on bus power supply
+                # 6..0: Reserved
                 tx_ints = [
                     0x59,  # ASCII 'Y'
                     DriverLubaRs232.LubaCmd.READ_WRITE_SETTINGS_CMD.value,  # LUBA Command
-                    2,  # Length
+                    3,  # Length
                     mode_settings,
                     event_settings,
+                    hardware_settings,
                     None,  # Checksum
                 ]
                 # Fill in the checksum
@@ -910,9 +926,29 @@ class DriverLubaRs232(DriverSerialBase):
                     f"Wrong event type 0x{self._buffer[1]:02x}, expected 0x21"
                 )
 
-            # QUERY DEVICE INFO supports two "sets" of data, this driver will
-            # only ever request set "0", so it is safe enough to assume that
-            # this is what the response refers to
+            # QUERY DEVICE INFO supports two "sets" of data, and the only way
+            # differentiate between them is to check for response length.
+            # When querying request set "0", response length should be 20 bytes,
+            # and for request set "1", response length should be 18 bytes.
+            # Currently this driver only ever requests set "0", therefore the
+            # harcoded response handling.
+            try:
+                payload_length = self._buffer[2]
+            except IndexError:
+                raise ValueError(
+                    f"Invalid data for QUERY DEVICE INFO response packet"
+                )
+
+            if payload_length not in [20, 18]:
+                raise ValueError(
+                    f"Unexpected payload length {payload_length} for QUERY DEVICE INFO response"
+                )
+
+            if payload_length == 18:
+                raise NotImplementedError(
+                    f"QUERY DEVICE INFO with set \"1\" is not yet implemented"
+                )
+
             info = DriverLubaRs232.LubaDeviceInfo(
                 gtin=int.from_bytes(bytes(received_data[3:9]), byteorder="big"),
                 id=int.from_bytes(bytes(received_data[9:17]), byteorder="big"),

{python-dali-0.11 → python_dali-0.12}/dali/driver/tridonic.py

@@ -2,8 +2,8 @@ from dali.command import from_frame
 from dali.driver.base import AsyncDALIDriver
 from dali.driver.base import DALIDriver
 from dali.driver.base import SyncDALIDriver
-from dali.driver.base import USBBackend
-from dali.driver.base import USBListener
+from dali.driver.usb import USBBackend
+from dali.driver.usb import USBListener
 from dali.frame import BackwardFrame
 from dali.frame import ForwardFrame
 import logging

{python-dali-0.11 → python_dali-0.12}/dali/driver/unipi.py

@@ -8,10 +8,15 @@
 import logging
 from time import sleep
 
-from pymodbus.client.sync import (
-    ModbusSerialClient as pySerial,
-    ModbusTcpClient as pyRtu,
-)
+import pymodbus
+from packaging import version
+
+PYMODBUS_VERSION = version.parse(pymodbus.__version__)
+
+if PYMODBUS_VERSION >= version.parse("3.0.0"):
+    from pymodbus.client import ModbusSerialClient, ModbusTcpClient
+else:
+    from pymodbus.client.sync import ModbusSerialClient, ModbusTcpClient
 
 from dali.driver.base import DALIDriver, SyncDALIDriver
 from dali.frame import BackwardFrame, ForwardFrame
@@ -40,11 +45,16 @@ class RemoteArm:
 
     def __init__(self, host, unit=1, baud=19200, timeout=1):
         if host.startswith("/"):
-            self.pymc = pySerial(
-                method="rtu", port=host, baudrate=baud, timeout=timeout
-            )
+            if PYMODBUS_VERSION >= version.parse("3.0.0"):
+                self.pymc = ModbusSerialClient(
+                    port=host, baudrate=baud, timeout=timeout
+                )
+            else:
+                self.pymc = ModbusSerialClient(
+                    method="rtu", port=host, baudrate=baud, timeout=timeout
+                )
         else:
-            self.pymc = pyRtu(host=host, port=502)
+            self.pymc = ModbusTcpClient(host=host, port=502)
         self.unit = unit
 
     def close(self):

python_dali-0.12/dali/driver/usb.py

@@ -0,0 +1,114 @@
+import threading
+import usb
+
+from dali.driver.base import Backend, Listener
+
+
+###############################################################################
+# 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()

{python-dali-0.11 → python_dali-0.12}/dali/gear/__init__.py

@@ -7,5 +7,6 @@ extensions and control gear specific features).
 import dali.gear.general
 import dali.gear.emergency
 import dali.gear.incandescent
+import dali.gear.converter
 import dali.gear.colour
 import dali.gear.led  # noqa: F401

python_dali-0.12/dali/gear/converter.py

@@ -0,0 +1,173 @@
+"""Commands and responses from IEC 62386 part 206.
+
+This part covers conversion from digital signal into DC voltage.
+"""
+
+from dali import command
+from dali.gear.general import _StandardCommand, QueryExtendedVersionNumberMixin
+
+
+class _ConversionCommand(_StandardCommand):
+    devicetype = 5
+
+
+class _ConversionConfigCommand(_ConversionCommand):
+    """An incandescent lighting configuration command as defined in
+    section 11.3.4.1 of IEC 62386-206:2009.
+    """
+    sendtwice = True
+
+
+###############################################################################
+# Commands from IEC 62386-206 section 11.3.4.1
+###############################################################################
+
+class SetOutputRange1To10V(_ConversionConfigCommand):
+    """Set the output range to 1V - 10V
+
+    Converters without this feature shall not react.
+    """
+    _cmdval = 224
+
+
+class SetOutputRange0To10V(_ConversionConfigCommand):
+    """Set the output range to 0V - 10V
+
+    Converters without this feature shall not react.
+    """
+    _cmdval = 225
+
+
+class SwitchOnInternalPullUp(_ConversionConfigCommand):
+    """Switch on the internal pull-up resistor at the control voltage output
+
+    Converters without this feature shall not react.
+    """
+    _cmdval = 226
+
+
+class SwitchOffInternalPullUp(_ConversionConfigCommand):
+    """Switch off the internal pull-up resistor at the control voltage output
+
+    Converters without this feature shall not react.
+    """
+    _cmdval = 227
+
+
+class StoreDtrAsPhysicalMinimum(_ConversionConfigCommand):
+    """The physical minimum level shall be changed to the value given in the DTR"""
+    _cmdval = 228
+
+
+class SelectDimmingCurve(_ConversionConfigCommand):
+    """Select Dimming Curve
+
+    If DTR0 is 0 then selects the standard logarithmic curve
+
+    If DTR0 is 1 then selects a linear dimming curve
+
+    Other values of DTR0 are reserved and will not change the dimming
+    curve.  The setting is stored in non-volatile memory and is not
+    cleared by the Reset command.
+    """
+    _cmdval = 229
+
+
+class ResetConverterSettings(_ConversionConfigCommand):
+    """Reset parameters which are not affected by RESET
+
+    All converter settings not influenced by the RESET command shall be set to the
+    default values given in clause 10 of IEC 62386-206:2009.
+    """
+    _cmdval = 230
+
+
+###############################################################################
+# Commands from IEC 62386-205 section 11.3.4.2
+###############################################################################
+
+class QueryDimmingCurve(_ConversionCommand):
+    """Query Dimming Curve
+
+    0 = standard logarithmic
+    1 = linear
+    2-255 = reserved for future use
+    """
+    _cmdval = 238
+    response = command.Response
+
+
+class OutputLevelResponse(command.NumericResponse):
+    def __str__(self):
+        if isinstance(self.value, int):
+            if self.value == 254:
+                return "10.16V or more"
+            elif self.value == 255:
+                return "unknown"
+            else:
+                return f"{self.value * 0.04} V"
+        return self.value
+
+
+class QueryOutputLevel(_ConversionCommand):
+    """Query the output level
+
+    The answer shall be the analog output level in units of 0.04V, fiving a range of 0V to 10.16V.
+
+    Raw value 254 maps to 10.16V or higher.
+    Raw value of 255 means "the output level is not known".
+
+    Converters without this feature shall not react.
+    """
+    _cmdval = 239
+    response = OutputLevelResponse
+
+
+class QueryConverterFeaturesResponse(command.BitmapResponse):
+    bits = [
+        "0V - 10V output selectable",
+        "internal pull-up selectable",
+        "detection of output fault selectable",
+        "mains relay",
+        "output level can be queried",
+        "non-logarithmic dimming curve supported",
+        "physical selection / lamp fail detection by loss out output supported",
+        "physical selection switch supported",
+    ]
+
+
+class QueryConverterFeatures(_ConversionCommand):
+    """Query hardware features of the converter"""
+    _cmdval = 240
+    response = QueryConverterFeaturesResponse
+
+
+class QueryFailureStatusResponse(command.BitmapResponse):
+    bits = [
+        "output fault detected",
+    ]
+
+
+class QueryFailureStatus(_ConversionCommand):
+    """Query failure status register"""
+    _cmdval = 241
+    response = QueryFailureStatusResponse
+
+
+class QueryConverterStatusResponse(command.BitmapResponse):
+    bits = [
+        "0-10V operation",
+        "internal pull-up on",
+        "non-logarithmic dimming curve active",
+    ]
+
+
+class QueryConverterStatus(_ConversionCommand):
+    """Query the current status of the converter"""
+    _cmdval = 242
+    response = QueryConverterStatusResponse
+
+
+class QueryExtendedVersionNumber(QueryExtendedVersionNumberMixin,
+                                 _ConversionCommand):
+    pass

{python-dali-0.11 → python_dali-0.12}/dali/gear/sequences.py

@@ -69,6 +69,7 @@ def QueryDT8ColourValue(
             "'query' must be a value from QueryColourValueDTR enumerator"
         )
 
+    # 62386-209, command 250, Note 2: start by sending "QUERY ACTUAL LEVEL"
     yield QueryActualLevel(address)
     yield DTR0(query.value)
     msb = yield QueryColourValue(address)

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

@@ -1,25 +1,29 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-dali
-Version: 0.11
+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
 ---------
@@ -160,11 +166,13 @@ Contributors
 
 - David Russell
 
+- Nikolay Korotkiy
+
 
 Copyright
 ---------
 
-python-dali is Copyright (C) 2013–2024 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
@@ -182,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.11 → python_dali-0.12}/python_dali.egg-info/SOURCES.txt

@@ -11,7 +11,6 @@ dali/command.py
 dali/exceptions.py
 dali/frame.py
 dali/sequences.py
-dali/version.py
 dali/device/__init__.py
 dali/device/general.py
 dali/device/helpers.py
@@ -29,8 +28,10 @@ dali/driver/serial.py
 dali/driver/trace_logging.py
 dali/driver/tridonic.py
 dali/driver/unipi.py
+dali/driver/usb.py
 dali/gear/__init__.py
 dali/gear/colour.py
+dali/gear/converter.py
 dali/gear/emergency.py
 dali/gear/general.py
 dali/gear/incandescent.py

{python-dali-0.11 → python_dali-0.12}/setup.cfg

@@ -1,13 +1,13 @@
 [metadata]
 name = python-dali
-version = 0.11
+version = 0.12
 description = Interface to DALI lighting systems
 long_description = file: README.rst
 long_description_content_type = text/x-rst
 author = Stephen Early
 author_email = steve@assorted.org.uk
 url = https://github.com/sde1000/python-dali
-license = LGPL3+
+license = "LGPL-3.0-or-later"
 license_files = 
 	COPYING
 	COPYING.LESSER
@@ -15,12 +15,10 @@ license_files =
 classifiers = 
 	Development Status :: 3 - Alpha
 	Intended Audience :: Developers
-	License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-	License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
 	Programming Language :: Python :: 3
 
 [options]
-python_requires = >=3.7
+python_requires = >=3.8
 packages = 
 	dali
 	dali.device

python-dali-0.11/dali/version.py

@@ -1 +0,0 @@
-version="0.11 (Fri, 03 May 2024 12:49:40 +0100)"

{python-dali-0.11 → python_dali-0.12}/python_dali.egg-info/requires.txt

@@ -3,10 +3,10 @@
 pyserial-asyncio
 
 [driver-unipi]
-pymodbus
 pyusb
+pymodbus
 
 [test]
-pyserial-asyncio
 pytest
 pytest-asyncio
+pyserial-asyncio