python-dali 0.10__py3-none-any.whl → 0.12__py3-none-any.whl

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

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

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

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

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()

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
         """
@@ -268,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
@@ -277,6 +304,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,9 +326,16 @@ 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")
+    # 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
@@ -353,11 +388,40 @@ 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):
+        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:
+                self._raw_write(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):
@@ -365,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
@@ -376,11 +440,10 @@ 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)
+                self._raw_write(data)
             except OSError:
                 # The device has failed.  Disconnect, schedule a
                 # reconnection, and report this command as failed.
@@ -391,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
@@ -406,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 \
@@ -419,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
@@ -443,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()
 
@@ -460,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)
@@ -473,7 +544,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:
@@ -490,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
@@ -502,18 +573,23 @@ class tridonic(hid):
                             current_command = None
                             continue
                         else:
-                            self._log.debug("Failed config command (second frame didn't match): %s", current_comment)
+                            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":
@@ -565,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])
@@ -589,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])
@@ -662,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.