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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-dali
-Version: 0.10
+Version: 0.11
 Summary: Interface to DALI lighting systems
 Home-page: https://github.com/sde1000/python-dali
 Author: Stephen Early
@@ -108,6 +108,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 +152,19 @@ Contributors
 
 - Sean Lanigan, Wallace Building Systems Pty Ltd
 
+- Markus Becker
+
+- Jan Kundrát
+
+- Olivier Pieters
+
+- David Russell
+
 
 Copyright
 ---------
 
-python-dali is Copyright (C) 2013–2022 Stephen Early <steve@assorted.org.uk>
+python-dali is Copyright (C) 2013–2024 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.11}/README.rst

@@ -85,6 +85,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 +129,19 @@ Contributors
 
 - Sean Lanigan, Wallace Building Systems Pty Ltd
 
+- Markus Becker
+
+- Jan Kundrát
+
+- Olivier Pieters
+
+- David Russell
+
 
 Copyright
 ---------
 
-python-dali is Copyright (C) 2013–2022 Stephen Early <steve@assorted.org.uk>
+python-dali is Copyright (C) 2013–2024 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.11}/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.11}/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.11}/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.11/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.11}/dali/driver/hid.py

@@ -123,18 +123,20 @@ class hid:
             path = glob.glob(self._path)
         else:
             path = [self._path]
+        ex = None
         if path:
             try:
                 if self._glob:
                     self._log.debug("trying concrete path %s", path[0])
                 self._f = os.open(path[0], os.O_RDWR | os.O_NONBLOCK)
-            except:
+            except Exception as e:
                 self._f = None
+                ex = e
         else:
             self._log.debug("path %s not found", self._path)
         if not self._f:
             # It didn't work.  Schedule a reconnection attempt if we can.
-            self._log.debug("hid failed to open %s - waiting to try again", self._path)
+            self._log.debug("hid failed to open %s (%s) - waiting to try again", self._path, ex)
             self._reconnect_task = asyncio.create_task(self._reconnect())
             return False
         self._reconnect_count = 0
@@ -208,6 +210,29 @@ class hid:
             if not in_transaction:
                 self.transaction_lock.release()
 
+    async def power_supply(self, supply_on, in_transaction=False, exceptions=None):
+        """
+        TODO
+        """
+        if exceptions is None:
+            exceptions = self.exceptions_on_send
+
+        if not in_transaction:
+            await self.transaction_lock.acquire()
+        try:
+            command_sent = False
+            while not command_sent:
+                try:
+                    response = await self._power_supply(supply_on)
+                    command_sent = True
+                except CommunicationError:
+                    if exceptions:
+                        raise
+            return response
+        finally:
+            if not in_transaction:
+                self.transaction_lock.release()
+
     async def run_sequence(self, seq, progress=None):
         """Run a command sequence as a transaction
         """
@@ -277,6 +302,7 @@ class tridonic(hid):
     _CMD_SET_IOPINS = 0x20
     _CMD_READ_IOPINS = 0x21
     _CMD_IDENTIFY = 0x22
+    _CMD_POWERSUPPLY = 0x40
 
     # For _CMD_INIT, send in byte 1:
     _CMD_INIT_READVERSION = 0x00
@@ -298,6 +324,11 @@ class tridonic(hid):
     _SEND_MODE_DALI24 = 6
     _SEND_MODE_HELVAR17 = 8
 
+    # For _CMD_POWERSUPPLY, send in byte 1;
+    _POWER_SUPPLY_OFF = 0x00
+    _POWER_SUPPLY_ON = 0x01
+    _POWER_SUPPLY_TBD = 0xFF # APPLY?
+
     # Responses received from the interface
     # Decodes to mode, response type, frame, interval, seq
     _resptmpl = struct.Struct(">BB4sHB55x")
@@ -358,6 +389,31 @@ class tridonic(hid):
         os.write(self._f, self._cmd(
             tridonic._CMD_INIT, tridonic._CMD_INIT_READVERSION))
 
+    async def _power_supply(self, supply_on):
+        await self.connected.wait()
+        async with self._command_semaphore:
+            data = self._cmd(self._CMD_POWERSUPPLY,
+                self._POWER_SUPPLY_ON if supply_on else self._POWER_SUPPLY_OFF)
+
+            try:
+                os.write(self._f, data)
+            except OSError:
+                # The device has failed.  Disconnect, schedule a
+                # reconnection, and report this command as failed.
+                self._log.debug("fail on transmit, disconnecting")
+                self.disconnect(reconnect=True)
+                raise CommunicationError
+
+    @staticmethod
+    def _command_mode(frame):
+        if len(frame) == 8:
+            return tridonic._SEND_MODE_DALI8
+        if len(frame) == 16:
+            return tridonic._SEND_MODE_DALI16
+        if len(frame) == 24:
+            return tridonic._SEND_MODE_DALI24
+        raise UnsupportedFrameTypeError
+
     async def _send_raw(self, command):
         frame = command.frame
         if len(frame) not in (16, 24):
@@ -376,8 +432,7 @@ class tridonic(hid):
             data = self._cmd(
                 self._CMD_SEND, seq,
                 ctrl=self._SEND_CTRL_SENDTWICE if command.sendtwice else 0,
-                mode=self._SEND_MODE_DALI16 if len(frame) == 16
-                else self._SEND_MODE_DALI24,
+                mode=self._command_mode(frame),
                 frame=frame.pack_len(4))
             try:
                 os.write(self._f, data)
@@ -473,7 +528,7 @@ class tridonic(hid):
                     frame = dali.frame.BackwardFrame(raw_frame)
                 elif rtype == self._RESPONSE_NO_FRAME:
                     frame = "no"
-                elif rtype == self._RESPONSE_BUS_STATUS \
+                elif rtype == self._RESPONSE_INFO \
                      and message[5] == self._BUS_STATUS_FRAMING_ERROR:
                     frame = dali.frame.BackwardFrameError(255)
                 else:
@@ -502,7 +557,7 @@ class tridonic(hid):
                             current_command = None
                             continue
                         else:
-                            self._log.debug("Failed config command (second frame didn't match): %s", current_comment)
+                            self._log.debug("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