dln2 0.1.0__py3-none-any.whl

dln2/__init__.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""
+Unified DLN2 wrapper package.
+
+Single USB connection shared by SPI, GPIO, I2C and ADC modules.
+Eliminates echo-counter conflicts and USB contention from the
+original four independent packages.
+
+Usage:
+    from dln2 import Dln2Connection, SpiDev, GPIO, SMBus, ADC, list_devices
+
+    conn = Dln2Connection()          # single USB connection
+    spi  = SpiDev(conn)              # all modules share conn
+    gpio = GPIO(conn)
+    i2c  = SMBus(conn)
+
+See also: dln2_wrapper.py (standalone legacy version)
+"""
+
+from ._core import Dln2Connection, list_devices, Dln2DeviceInfo
+from .spi import SpiDev
+from .gpio import GPIO, \
+    GPIO_EVENT_NONE, GPIO_EVENT_CHANGE, \
+    GPIO_EVENT_LEVEL_HIGH, GPIO_EVENT_LEVEL_LOW
+from .i2c import SMBus, i2c_msg
+from .adc import ADC
+from .bme280 import BME280

dln2/_core.py

@@ -0,0 +1,505 @@
+#!/usr/bin/env python3
+"""DLN2 unified USB connection — single client for SPI + GPIO + I2C + ADC."""
+
+import struct
+import time
+import usb.core
+import usb.util
+
+VID = 0x1D50
+PID = 0x6170
+
+# ═══════════════════════════════════════════════════════════════
+# DLN2 protocol constants
+# ═══════════════════════════════════════════════════════════════
+
+DLN2_MODULE_GENERIC = 0x00
+DLN2_MODULE_GPIO    = 0x01
+DLN2_MODULE_SPI     = 0x02
+DLN2_MODULE_I2C     = 0x03
+DLN2_MODULE_ADC     = 0x06
+
+DLN2_HANDLE_CTRL = 1
+DLN2_HANDLE_GPIO = 2
+DLN2_HANDLE_I2C  = 3
+DLN2_HANDLE_SPI  = 4
+DLN2_HANDLE_ADC  = 5
+DLN2_HANDLE_EVENT = 0
+
+def DLN2_CMD(cmd, module):
+    return (cmd & 0xFF) | ((module & 0xFF) << 8)
+
+# ── SPI ───────────────────────────────────────────────────────
+DLN2_SPI_ENABLE         = DLN2_CMD(0x11, DLN2_MODULE_SPI)
+DLN2_SPI_DISABLE        = DLN2_CMD(0x12, DLN2_MODULE_SPI)
+DLN2_SPI_SET_MODE       = DLN2_CMD(0x14, DLN2_MODULE_SPI)
+DLN2_SPI_SET_FRAME_SIZE = DLN2_CMD(0x16, DLN2_MODULE_SPI)
+DLN2_SPI_SET_FREQUENCY  = DLN2_CMD(0x18, DLN2_MODULE_SPI)
+DLN2_SPI_READ_WRITE     = DLN2_CMD(0x1A, DLN2_MODULE_SPI)
+DLN2_SPI_READ           = DLN2_CMD(0x1B, DLN2_MODULE_SPI)
+DLN2_SPI_WRITE          = DLN2_CMD(0x1C, DLN2_MODULE_SPI)
+DLN2_SPI_GET_SS_COUNT   = DLN2_CMD(0x44, DLN2_MODULE_SPI)
+DLN2_SPI_SS_MULTI_ENABLE  = DLN2_CMD(0x38, DLN2_MODULE_SPI)
+DLN2_SPI_SS_MULTI_DISABLE = DLN2_CMD(0x39, DLN2_MODULE_SPI)
+
+# ── GPIO ──────────────────────────────────────────────────────
+DLN2_GPIO_GET_PIN_COUNT     = DLN2_CMD(0x01, DLN2_MODULE_GPIO)
+DLN2_GPIO_PIN_GET_VAL       = DLN2_CMD(0x0B, DLN2_MODULE_GPIO)
+DLN2_GPIO_PIN_SET_OUT_VAL   = DLN2_CMD(0x0C, DLN2_MODULE_GPIO)
+DLN2_GPIO_PIN_GET_OUT_VAL   = DLN2_CMD(0x0D, DLN2_MODULE_GPIO)
+DLN2_GPIO_CONDITION_MET_EV  = DLN2_CMD(0x0F, DLN2_MODULE_GPIO)
+DLN2_GPIO_PIN_ENABLE        = DLN2_CMD(0x10, DLN2_MODULE_GPIO)
+DLN2_GPIO_PIN_DISABLE       = DLN2_CMD(0x11, DLN2_MODULE_GPIO)
+DLN2_GPIO_PIN_SET_DIRECTION = DLN2_CMD(0x13, DLN2_MODULE_GPIO)
+DLN2_GPIO_PIN_GET_DIRECTION = DLN2_CMD(0x14, DLN2_MODULE_GPIO)
+DLN2_GPIO_PIN_SET_EVENT_CFG = DLN2_CMD(0x1E, DLN2_MODULE_GPIO)
+
+GPIO_EVENT_NONE        = 0
+GPIO_EVENT_CHANGE      = 1
+GPIO_EVENT_LEVEL_HIGH  = 2
+GPIO_EVENT_LEVEL_LOW   = 3
+
+# ── I2C ───────────────────────────────────────────────────────
+DLN2_I2C_ENABLE  = DLN2_CMD(0x01, DLN2_MODULE_I2C)
+DLN2_I2C_DISABLE = DLN2_CMD(0x02, DLN2_MODULE_I2C)
+DLN2_I2C_WRITE   = DLN2_CMD(0x06, DLN2_MODULE_I2C)
+DLN2_I2C_READ    = DLN2_CMD(0x07, DLN2_MODULE_I2C)
+
+# ── ADC ───────────────────────────────────────────────────────
+DLN2_ADC_GET_CHANNEL_COUNT = DLN2_CMD(0x01, DLN2_MODULE_ADC)
+DLN2_ADC_ENABLE            = DLN2_CMD(0x02, DLN2_MODULE_ADC)
+DLN2_ADC_DISABLE           = DLN2_CMD(0x03, DLN2_MODULE_ADC)
+DLN2_ADC_CHANNEL_ENABLE    = DLN2_CMD(0x05, DLN2_MODULE_ADC)
+DLN2_ADC_CHANNEL_DISABLE   = DLN2_CMD(0x06, DLN2_MODULE_ADC)
+DLN2_ADC_SET_RESOLUTION    = DLN2_CMD(0x08, DLN2_MODULE_ADC)
+DLN2_ADC_CHANNEL_GET_VAL   = DLN2_CMD(0x0A, DLN2_MODULE_ADC)
+DLN2_ADC_CHANNEL_GET_ALL_VAL = DLN2_CMD(0x0B, DLN2_MODULE_ADC)
+
+
+class Dln2DeviceInfo:
+    """Metadata for one connected DLN2 device."""
+    __slots__ = ("dev", "serial", "index")
+
+    def __init__(self, dev, serial, index):
+        self.dev = dev
+        self.serial = serial
+        self.index = index
+
+
+def list_devices():
+    """Return list of all connected DLN2 devices."""
+    devices = []
+    for i, dev in enumerate(usb.core.find(find_all=True,
+                                          idVendor=VID, idProduct=PID)):
+        try:
+            serial = usb.util.get_string(dev, dev.iSerialNumber)
+        except Exception:
+            serial = ""
+        devices.append(Dln2DeviceInfo(dev=dev, serial=serial, index=i))
+    return devices
+
+
+class Dln2Connection:
+    """Unified DLN2 client — SPI + GPIO + I2C + ADC share one USB connection."""
+
+    def __init__(self, index=None, serial=None, debug=False):
+        self.debug = bool(debug)
+        self._echo = 1
+        self._event_queue = []
+
+        devices = list_devices()
+        if not devices:
+            raise ValueError(f"No DLN2 device found ({VID:04X}:{PID:04X})")
+
+        if serial is not None:
+            match = next((d for d in devices if d.serial == serial), None)
+            if not match:
+                raise ValueError(f"No DLN2 with serial {serial}")
+            self._dev = match.dev
+        elif index is not None:
+            if index >= len(devices):
+                raise ValueError(
+                    f"DLN2 index {index} out of range ({len(devices)} found)")
+            self._dev = devices[index].dev
+        else:
+            self._dev = devices[0].dev
+
+        self._setup()
+
+    def _setup(self):
+        # Reset USB to clear stale state
+        try:
+            self._dev.reset()
+        except Exception:
+            pass
+
+        try:
+            self._dev.set_configuration()
+        except Exception:
+            pass
+
+        cfg = self._dev.get_active_configuration()
+        intf = cfg[(0, 0)]
+
+        ep_out = ep_in = None
+        for ep in intf.endpoints():
+            d = usb.util.endpoint_direction(ep.bEndpointAddress)
+            t = usb.util.endpoint_type(ep.bmAttributes)
+            if d == usb.util.ENDPOINT_OUT and t == usb.util.ENDPOINT_TYPE_BULK:
+                ep_out = ep
+            if d == usb.util.ENDPOINT_IN and t == usb.util.ENDPOINT_TYPE_BULK:
+                ep_in = ep
+        if not ep_out or not ep_in:
+            raise RuntimeError("No bulk endpoints found on DLN2")
+        self._ep_out = ep_out.bEndpointAddress
+        self._ep_in = ep_in.bEndpointAddress
+        self._interface = intf.bInterfaceNumber
+
+        if self._dev.is_kernel_driver_active(self._interface):
+            try:
+                self._dev.detach_kernel_driver(self._interface)
+            except Exception:
+                pass
+        usb.util.claim_interface(self._dev, self._interface)
+
+    # ─── USB raw ──────────────────────────────────────────────
+    def _send_raw(self, data: bytes):
+        self._dev.write(self._ep_out, data, timeout=2000)
+
+    def _read_raw(self, size=1024, timeout_ms=2000):
+        return bytes(self._dev.read(self._ep_in, size, timeout=timeout_ms))
+
+    # ─── Unified command dispatch ──────────────────────────
+    def send_cmd(self, cmd_id, payload=b"", handle=DLN2_HANDLE_SPI):
+        hdr_size = 8
+        size = hdr_size + len(payload)
+        pkt = struct.pack("<HHHH", size, cmd_id, self._echo & 0xFFFF,
+                          handle & 0xFFFF) + payload
+        expected = self._echo & 0xFFFF
+        self._echo = (self._echo + 1) & 0xFFFF
+
+        if self.debug:
+            print(f"[DLN2] OUT echo={expected} cmd=0x{cmd_id:04X} "
+                  f"handle={handle} len={len(payload)}")
+
+        self._send_raw(pkt)
+
+        # Read — retry for large payloads
+        deadline = time.monotonic() + 10.0
+        while time.monotonic() < deadline:
+            try:
+                raw = self._read_raw(1024, timeout_ms=3000)
+            except Exception:
+                time.sleep(0.05)
+                continue
+
+            if len(raw) < 10:
+                time.sleep(0.05)
+                continue
+
+            sz, rid, echo, hnd, result = struct.unpack("<HHHHH", raw[:10])
+            data = raw[10:sz]
+
+            if self.debug:
+                print(f"  IN echo={echo} result={result} data={data[:16].hex()}")
+
+            if hnd == DLN2_HANDLE_EVENT:
+                # Queue event for GPIO.poll_event()
+                self._queue_event(raw)
+                continue  # read next response
+
+            if echo != expected:
+                raise RuntimeError(
+                    f"Echo mismatch: got {echo}, expected {expected}")
+
+            return {"result": result, "data": data, "echo": echo}
+
+        raise RuntimeError("Timeout waiting for DLN2 response")
+
+    def _queue_event(self, raw):
+        """Decode and queue a GPIO event packet."""
+        if len(raw) < 16:
+            return
+        try:
+            # Event packet: size, id, echo, handle(0), result
+            # Followed by event_type(2B) + pin(2B) + ?
+            _, _, _, _, _ = struct.unpack("<HHHHH", raw[:10])
+            ev_type = struct.unpack("<H", raw[10:12])[0]
+            ev_data = raw[12:14]  # variable
+            self._event_queue.append({
+                "type": ev_type,
+                "pin": ev_data[0],
+                "value": ev_data[1] if len(ev_data) > 1 else 0,
+            })
+        except Exception:
+            pass
+
+    def close(self):
+        try:
+            usb.util.release_interface(self._dev, self._interface)
+        except Exception:
+            pass
+
+    # ═══════════════════════════════════════════════════════════
+    # SPI raw
+    # ═══════════════════════════════════════════════════════════
+
+    def spi_configure(self, mode, freq_hz, bpw=8):
+        self.send_cmd(DLN2_SPI_SET_FRAME_SIZE,
+                      struct.pack("<BB", 0, bpw),
+                      handle=DLN2_HANDLE_SPI)
+        self.send_cmd(DLN2_SPI_SET_FREQUENCY,
+                      struct.pack("<BI", 0, freq_hz),
+                      handle=DLN2_HANDLE_SPI)
+        self.send_cmd(DLN2_SPI_SET_MODE,
+                      struct.pack("<BB", 0, mode & 3),
+                      handle=DLN2_HANDLE_SPI)
+
+    def spi_enable(self):
+        self.send_cmd(DLN2_SPI_ENABLE, struct.pack("<B", 0),
+                      handle=DLN2_HANDLE_SPI)
+
+    def spi_disable(self):
+        self.send_cmd(DLN2_SPI_DISABLE, struct.pack("<BB", 0, 0),
+                      handle=DLN2_HANDLE_SPI)
+
+    def spi_read_write(self, tx_bytes, leave_ss_low=False):
+        attr = 1 if leave_ss_low else 0
+        payload = struct.pack("<BHB", 0, len(tx_bytes) & 0xFFFF,
+                              attr & 0xFF) + tx_bytes
+        resp = self.send_cmd(DLN2_SPI_READ_WRITE, payload,
+                             handle=DLN2_HANDLE_SPI)
+        if resp["result"] != 0:
+            raise RuntimeError(f"SPI transfer failed: result={resp['result']}")
+        if len(resp["data"]) < 2:
+            raise RuntimeError("SPI response too short")
+        rx_len = struct.unpack("<H", resp["data"][:2])[0]
+        return resp["data"][2:2 + rx_len]
+
+    def spi_write(self, data, leave_ss_low=False):
+        attr = 1 if leave_ss_low else 0
+        for i in range(0, len(data), 128):
+            chunk = data[i:i + 128]
+            pkt = struct.pack("<BHB", 0, len(chunk), attr) + chunk
+            self.send_cmd(DLN2_SPI_WRITE, pkt, handle=DLN2_HANDLE_SPI)
+
+    # ═══════════════════════════════════════════════════════════
+    # GPIO raw
+    # ═══════════════════════════════════════════════════════════
+
+    def gpio_get_pin_count(self):
+        resp = self.send_cmd(DLN2_GPIO_GET_PIN_COUNT, b"",
+                             handle=DLN2_HANDLE_GPIO)
+        if resp["result"] != 0:
+            raise RuntimeError(f"GPIO get_pin_count failed: {resp['result']}")
+        if len(resp["data"]) < 2:
+            raise RuntimeError("GPIO get_pin_count response too short")
+        return struct.unpack("<H", resp["data"][:2])[0]
+
+    def gpio_pin_enable(self, pin):
+        resp = self.send_cmd(DLN2_GPIO_PIN_ENABLE,
+                             struct.pack("<H", int(pin)),
+                             handle=DLN2_HANDLE_GPIO)
+        if resp["result"] != 0:
+            raise RuntimeError(f"GPIO pin_enable({pin}) failed: {resp['result']}")
+
+    def gpio_pin_disable(self, pin):
+        resp = self.send_cmd(DLN2_GPIO_PIN_DISABLE,
+                             struct.pack("<H", int(pin)),
+                             handle=DLN2_HANDLE_GPIO)
+        if resp["result"] != 0:
+            raise RuntimeError(f"GPIO pin_disable({pin}) failed: {resp['result']}")
+
+    def gpio_pin_set_direction(self, pin, is_output):
+        resp = self.send_cmd(DLN2_GPIO_PIN_SET_DIRECTION,
+                             struct.pack("<HB", int(pin), 1 if is_output else 0),
+                             handle=DLN2_HANDLE_GPIO)
+        if resp["result"] != 0:
+            raise RuntimeError(
+                f"GPIO set_direction({pin}) failed: {resp['result']}")
+
+    def gpio_pin_get_direction(self, pin):
+        resp = self.send_cmd(DLN2_GPIO_PIN_GET_DIRECTION,
+                             struct.pack("<H", int(pin)),
+                             handle=DLN2_HANDLE_GPIO)
+        if resp["result"] != 0:
+            raise RuntimeError(
+                f"GPIO get_direction({pin}) failed: {resp['result']}")
+        if len(resp["data"]) < 3:
+            raise RuntimeError("GPIO get_direction response too short")
+        _, direction = struct.unpack("<HB", resp["data"][:3])
+        return bool(direction)
+
+    def gpio_get(self, pin):
+        resp = self.send_cmd(DLN2_GPIO_PIN_GET_VAL,
+                             struct.pack("<H", int(pin)),
+                             handle=DLN2_HANDLE_GPIO)
+        if resp["result"] != 0:
+            raise RuntimeError(f"GPIO get_val({pin}) failed: {resp['result']}")
+        if len(resp["data"]) < 3:
+            raise RuntimeError("GPIO get_val response too short")
+        _, value = struct.unpack("<HB", resp["data"][:3])
+        return value
+
+    def gpio_set(self, pin, value):
+        resp = self.send_cmd(DLN2_GPIO_PIN_SET_OUT_VAL,
+                             struct.pack("<HB", int(pin), 1 if value else 0),
+                             handle=DLN2_HANDLE_GPIO)
+        if resp["result"] != 0:
+            raise RuntimeError(f"GPIO set_out_val({pin}) failed: {resp['result']}")
+
+    def gpio_get_out_val(self, pin):
+        resp = self.send_cmd(DLN2_GPIO_PIN_GET_OUT_VAL,
+                             struct.pack("<H", int(pin)),
+                             handle=DLN2_HANDLE_GPIO)
+        if resp["result"] != 0:
+            raise RuntimeError(
+                f"GPIO get_out_val({pin}) failed: {resp['result']}")
+        if len(resp["data"]) < 3:
+            raise RuntimeError("GPIO get_out_val response too short")
+        _, value = struct.unpack("<HB", resp["data"][:3])
+        return value
+
+    def gpio_set_event_cfg(self, pin, event_type, period=0):
+        resp = self.send_cmd(DLN2_GPIO_PIN_SET_EVENT_CFG,
+                             struct.pack("<HBH", int(pin), int(event_type),
+                                         int(period)),
+                             handle=DLN2_HANDLE_GPIO)
+        if resp["result"] != 0:
+            raise RuntimeError(
+                f"GPIO set_event_cfg({pin}) failed: {resp['result']}")
+
+    def gpio_poll_event(self, timeout_ms=0):
+        if self._event_queue:
+            return self._event_queue.pop(0)
+        try:
+            raw = self._read_raw(1024, timeout_ms=timeout_ms)
+            if len(raw) < 10:
+                return None
+            # Parse as event
+            self._queue_event(raw)
+            if self._event_queue:
+                return self._event_queue.pop(0)
+        except Exception:
+            pass
+        return None
+
+    # ═══════════════════════════════════════════════════════════
+    # I2C raw
+    # ═══════════════════════════════════════════════════════════
+
+    def i2c_enable(self):
+        return self.send_cmd(DLN2_I2C_ENABLE, struct.pack("<B", 0),
+                            handle=DLN2_HANDLE_I2C)
+
+    def i2c_disable(self):
+        return self.send_cmd(DLN2_I2C_DISABLE, struct.pack("<B", 0),
+                            handle=DLN2_HANDLE_I2C)
+
+    def i2c_write(self, addr, data, mem_addr_len=0, mem_addr=0):
+        tx = bytes(data)
+        payload = struct.pack("<BBBIH", 0, int(addr) & 0x7F,
+                              int(mem_addr_len) & 0xFF,
+                              int(mem_addr) & 0xFFFFFFFF,
+                              len(tx) & 0xFFFF) + tx
+        resp = self.send_cmd(DLN2_I2C_WRITE, payload,
+                             handle=DLN2_HANDLE_I2C)
+        if resp["result"] != 0:
+            raise RuntimeError(f"I2C write(0x{addr:02X}) failed: {resp['result']}")
+        return resp
+
+    def i2c_read(self, addr, length, mem_addr_len=0, mem_addr=0):
+        payload = struct.pack("<BBBIH", 0, int(addr) & 0x7F,
+                              int(mem_addr_len) & 0xFF,
+                              int(mem_addr) & 0xFFFFFFFF,
+                              int(length) & 0xFFFF)
+        resp = self.send_cmd(DLN2_I2C_READ, payload,
+                             handle=DLN2_HANDLE_I2C)
+        if resp["result"] != 0:
+            raise RuntimeError(f"I2C read(0x{addr:02X}) failed: {resp['result']}")
+        if len(resp["data"]) < 2:
+            raise RuntimeError("I2C response too short")
+        rx_len = struct.unpack("<H", resp["data"][:2])[0]
+        rx = resp["data"][2:2 + rx_len]
+        if len(rx) != rx_len:
+            raise RuntimeError("Short I2C read payload")
+        return rx
+
+    # ═══════════════════════════════════════════════════════════
+    # ADC raw
+    # ═══════════════════════════════════════════════════════════
+
+    def adc_get_channel_count(self, port=0):
+        resp = self.send_cmd(DLN2_ADC_GET_CHANNEL_COUNT,
+                             struct.pack("<B", port & 0xFF),
+                             handle=DLN2_HANDLE_ADC)
+        if resp["result"] != 0:
+            raise RuntimeError(f"ADC get_channel_count failed: {resp['result']}")
+        if len(resp["data"]) != 1:
+            raise RuntimeError("ADC channel count response size mismatch")
+        return resp["data"][0]
+
+    def adc_enable(self, port=0):
+        resp = self.send_cmd(DLN2_ADC_ENABLE,
+                             struct.pack("<B", port & 0xFF),
+                             handle=DLN2_HANDLE_ADC)
+        if resp["result"] != 0:
+            raise RuntimeError(f"ADC enable failed: {resp['result']}")
+        if len(resp["data"]) < 2:
+            raise RuntimeError("ADC enable response too short")
+        return struct.unpack("<H", resp["data"][:2])[0]
+
+    def adc_disable(self, port=0):
+        resp = self.send_cmd(DLN2_ADC_DISABLE,
+                             struct.pack("<B", port & 0xFF),
+                             handle=DLN2_HANDLE_ADC)
+        if resp["result"] != 0:
+            raise RuntimeError(f"ADC disable failed: {resp['result']}")
+        if len(resp["data"]) < 2:
+            raise RuntimeError("ADC disable response too short")
+        return struct.unpack("<H", resp["data"][:2])[0]
+
+    def adc_channel_enable(self, channel, port=0):
+        resp = self.send_cmd(DLN2_ADC_CHANNEL_ENABLE,
+                             struct.pack("<BB", port & 0xFF, int(channel) & 0xFF),
+                             handle=DLN2_HANDLE_ADC)
+        if resp["result"] != 0:
+            raise RuntimeError(
+                f"ADC channel_enable({channel}) failed: {resp['result']}")
+
+    def adc_channel_disable(self, channel, port=0):
+        resp = self.send_cmd(DLN2_ADC_CHANNEL_DISABLE,
+                             struct.pack("<BB", port & 0xFF, int(channel) & 0xFF),
+                             handle=DLN2_HANDLE_ADC)
+        if resp["result"] != 0:
+            raise RuntimeError(
+                f"ADC channel_disable({channel}) failed: {resp['result']}")
+
+    def adc_set_resolution(self, bits, port=0):
+        resp = self.send_cmd(DLN2_ADC_SET_RESOLUTION,
+                             struct.pack("<BB", port & 0xFF, int(bits) & 0xFF),
+                             handle=DLN2_HANDLE_ADC)
+        if resp["result"] != 0:
+            raise RuntimeError(f"ADC set_resolution failed: {resp['result']}")
+
+    def adc_read_channel(self, channel, port=0):
+        resp = self.send_cmd(DLN2_ADC_CHANNEL_GET_VAL,
+                             struct.pack("<BB", port & 0xFF, int(channel) & 0xFF),
+                             handle=DLN2_HANDLE_ADC)
+        if resp["result"] != 0:
+            raise RuntimeError(f"ADC read_channel failed: {resp['result']}")
+        if len(resp["data"]) < 2:
+            raise RuntimeError("ADC read_channel response too short")
+        return struct.unpack("<H", resp["data"][:2])[0]
+
+    def adc_read_all(self, port=0):
+        resp = self.send_cmd(DLN2_ADC_CHANNEL_GET_ALL_VAL,
+                             struct.pack("<B", port & 0xFF),
+                             handle=DLN2_HANDLE_ADC)
+        if resp["result"] != 0:
+            raise RuntimeError(f"ADC read_all failed: {resp['result']}")
+        if len(resp["data"]) < 18:
+            raise RuntimeError("ADC read_all response too short")
+        channel_mask = struct.unpack("<H", resp["data"][:2])[0]
+        values = list(struct.unpack("<8H", resp["data"][2:18]))
+        return {"channel_mask": channel_mask, "values": values}

dln2/adc.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""DLN2 ADC wrapper."""
+
+
+class ADC:
+    MAX_CHANNELS = 3
+    DEFAULT_VREF = 3.3
+    DEFAULT_BITS = 10
+    DEFAULT_MAX_VALUE = (1 << DEFAULT_BITS) - 1
+
+    def __init__(self, connection=None, port=0, resolution_bits=10,
+                 vref=3.3):
+        if connection is None:
+            from ._core import Dln2Connection
+            connection = Dln2Connection()
+        self._conn = connection
+        self.port = int(port)
+        self.resolution_bits = int(resolution_bits)
+        self.vref = float(vref)
+        self._enabled = False
+
+    def open(self):
+        if self._enabled:
+            return self
+        self._conn.adc_enable(self.port)
+        self._conn.adc_set_resolution(self.resolution_bits, self.port)
+        self._enabled = True
+        return self
+
+    def close(self):
+        if not self._enabled:
+            return
+        try:
+            self._conn.adc_disable(self.port)
+        except Exception:
+            pass
+        self._enabled = False
+
+    def _require(self):
+        if not self._enabled:
+            self.open()
+        return self._conn
+
+    def get_channel_count(self):
+        return self._require().adc_get_channel_count(self.port)
+
+    def enable_channel(self, channel):
+        self._validate(channel)
+        self._require().adc_channel_enable(channel, self.port)
+
+    def disable_channel(self, channel):
+        self._validate(channel)
+        self._require().adc_channel_disable(channel, self.port)
+
+    def set_resolution(self, bits):
+        self.resolution_bits = int(bits)
+        self._require().adc_set_resolution(self.resolution_bits, self.port)
+
+    def read_channel(self, channel, enable=False):
+        self._validate(channel)
+        c = self._require()
+        if enable:
+            c.adc_channel_enable(channel, self.port)
+        return c.adc_read_channel(channel, self.port)
+
+    def read_all(self):
+        data = self._require().adc_read_all(self.port)
+        return {
+            "channel_mask": data["channel_mask"],
+            "values": data["values"][:self.MAX_CHANNELS],
+        }
+
+    def read_volts(self, channel, enable=False):
+        raw = self.read_channel(channel, enable=enable)
+        return float(raw) * self.vref / self.DEFAULT_MAX_VALUE
+
+    def to_voltage(self, raw):
+        return float(raw) * self.vref / self.DEFAULT_MAX_VALUE
+
+    def _validate(self, channel):
+        channel = int(channel)
+        if channel < 0 or channel >= self.MAX_CHANNELS:
+            raise ValueError(f"ADC channel must be in range 0..{self.MAX_CHANNELS - 1}")
+
+    def __enter__(self):
+        return self.open()
+
+    def __exit__(self, *a):
+        self.close()

dln2/bme280.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""
+Minimal BME280 helper built on top of the DLN2 SMBus wrapper.
+"""
+
+import struct
+
+from .i2c import SMBus
+
+
+class BME280:
+    CHIP_ID_REGISTER = 0xD0
+    RESET_REGISTER = 0xE0
+    STATUS_REGISTER = 0xF3
+    CTRL_HUM_REGISTER = 0xF2
+    CTRL_MEAS_REGISTER = 0xF4
+    CONFIG_REGISTER = 0xF5
+    DATA_REGISTER = 0xF7
+
+    EXPECTED_CHIP_ID = 0x60
+
+    def __init__(self, bus=1, address=0x76, debug=False):
+        if isinstance(bus, SMBus):
+            self.bus = bus
+            self._owns_bus = False
+        elif hasattr(bus, 'send_cmd'):   # Dln2Connection passed directly
+            self.bus = SMBus(connection=bus)
+            self._owns_bus = True
+        else:
+            self.bus = SMBus()
+            self._owns_bus = True
+
+        self.address = int(address) & 0x7F
+        self.debug = bool(debug)
+        self.calibration = None
+        self.t_fine = 0.0
+
+    def close(self):
+        if self._owns_bus:
+            self.bus.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        self.close()
+
+    def read_chip_id(self):
+        return self.bus.read_byte_data(self.address, self.CHIP_ID_REGISTER)
+
+    def check_chip_id(self):
+        chip_id = self.read_chip_id()
+        if chip_id != self.EXPECTED_CHIP_ID:
+            raise RuntimeError(
+                f"Unexpected BME280 chip ID: 0x{chip_id:02x} at 0x{self.address:02x}"
+            )
+        return chip_id
+
+    def reset(self):
+        self.bus.write_byte_data(self.address, self.RESET_REGISTER, 0xB6)
+
+    def configure(self, osrs_t=1, osrs_p=1, osrs_h=1, mode=3, standby=5, filter_coef=0):
+        self.bus.write_byte_data(self.address, self.CTRL_HUM_REGISTER, osrs_h & 0x07)
+        ctrl_meas = ((osrs_t & 0x07) << 5) | ((osrs_p & 0x07) << 2) | (mode & 0x03)
+        config = ((standby & 0x07) << 5) | ((filter_coef & 0x07) << 2)
+        self.bus.write_byte_data(self.address, self.CONFIG_REGISTER, config)
+        self.bus.write_byte_data(self.address, self.CTRL_MEAS_REGISTER, ctrl_meas)
+
+    def read_calibration(self):
+        block1 = self.bus.read_i2c_block_data(self.address, 0x88, 26)
+        block2 = self.bus.read_i2c_block_data(self.address, 0xE1, 7)
+
+        calib1 = bytes(block1)
+        calib2 = bytes(block2)
+
+        self.calibration = {
+            "dig_T1": struct.unpack_from("<H", calib1, 0)[0],
+            "dig_T2": struct.unpack_from("<h", calib1, 2)[0],
+            "dig_T3": struct.unpack_from("<h", calib1, 4)[0],
+            "dig_P1": struct.unpack_from("<H", calib1, 6)[0],
+            "dig_P2": struct.unpack_from("<h", calib1, 8)[0],
+            "dig_P3": struct.unpack_from("<h", calib1, 10)[0],
+            "dig_P4": struct.unpack_from("<h", calib1, 12)[0],
+            "dig_P5": struct.unpack_from("<h", calib1, 14)[0],
+            "dig_P6": struct.unpack_from("<h", calib1, 16)[0],
+            "dig_P7": struct.unpack_from("<h", calib1, 18)[0],
+            "dig_P8": struct.unpack_from("<h", calib1, 20)[0],
+            "dig_P9": struct.unpack_from("<h", calib1, 22)[0],
+            "dig_H1": calib1[25],
+            "dig_H2": struct.unpack_from("<h", calib2, 0)[0],
+            "dig_H3": calib2[2],
+            "dig_H4": (calib2[3] << 4) | (calib2[4] & 0x0F),
+            "dig_H5": (calib2[5] << 4) | (calib2[4] >> 4),
+            "dig_H6": struct.unpack_from("<b", calib2, 6)[0],
+        }
+        if self.calibration["dig_H4"] & 0x800:
+            self.calibration["dig_H4"] -= 4096
+        if self.calibration["dig_H5"] & 0x800:
+            self.calibration["dig_H5"] -= 4096
+        return self.calibration
+
+    def _ensure_calibration(self):
+        if self.calibration is None:
+            self.read_calibration()
+        return self.calibration
+
+    def read_raw_data(self):
+        data = self.bus.read_i2c_block_data(self.address, self.DATA_REGISTER, 8)
+        raw_press = (data[0] << 12) | (data[1] << 4) | (data[2] >> 4)
+        raw_temp = (data[3] << 12) | (data[4] << 4) | (data[5] >> 4)
+        raw_hum = (data[6] << 8) | data[7]
+        return {
+            "pressure": raw_press,
+            "temperature": raw_temp,
+            "humidity": raw_hum,
+        }
+
+    def compensate_temperature(self, adc_t):
+        cal = self._ensure_calibration()
+        var1 = (adc_t / 16384.0 - cal["dig_T1"] / 1024.0) * cal["dig_T2"]
+        var2 = (
+            (adc_t / 131072.0 - cal["dig_T1"] / 8192.0)
+            * (adc_t / 131072.0 - cal["dig_T1"] / 8192.0)
+            * cal["dig_T3"]
+        )
+        self.t_fine = var1 + var2
+        return self.t_fine / 5120.0
+
+    def compensate_pressure(self, adc_p):
+        cal = self._ensure_calibration()
+        var1 = self.t_fine / 2.0 - 64000.0
+        var2 = var1 * var1 * cal["dig_P6"] / 32768.0
+        var2 = var2 + var1 * cal["dig_P5"] * 2.0
+        var2 = var2 / 4.0 + cal["dig_P4"] * 65536.0
+        var1 = (
+            cal["dig_P3"] * var1 * var1 / 524288.0 + cal["dig_P2"] * var1
+        ) / 524288.0
+        var1 = (1.0 + var1 / 32768.0) * cal["dig_P1"]
+        if var1 == 0:
+            return 0.0
+
+        pressure = 1048576.0 - adc_p
+        pressure = (pressure - var2 / 4096.0) * 6250.0 / var1
+        var1 = cal["dig_P9"] * pressure * pressure / 2147483648.0
+        var2 = pressure * cal["dig_P8"] / 32768.0
+        pressure = pressure + (var1 + var2 + cal["dig_P7"]) / 16.0
+        return pressure / 100.0
+
+    def compensate_humidity(self, adc_h):
+        cal = self._ensure_calibration()
+        humidity = self.t_fine - 76800.0
+        humidity = (
+            adc_h
+            - (cal["dig_H4"] * 64.0 + cal["dig_H5"] / 16384.0 * humidity)
+        ) * (
+            cal["dig_H2"]
+            / 65536.0
+            * (
+                1.0
+                + cal["dig_H6"] / 67108864.0 * humidity
+                * (1.0 + cal["dig_H3"] / 67108864.0 * humidity)
+            )
+        )
+        humidity = humidity * (1.0 - cal["dig_H1"] * humidity / 524288.0)
+        if humidity < 0.0:
+            return 0.0
+        if humidity > 100.0:
+            return 100.0
+        return humidity
+
+    def read_measurements(self):
+        raw = self.read_raw_data()
+        temperature_c = self.compensate_temperature(raw["temperature"])
+        pressure_hpa = self.compensate_pressure(raw["pressure"])
+        humidity_percent = self.compensate_humidity(raw["humidity"])
+        return {
+            "temperature_c": temperature_c,
+            "pressure_hpa": pressure_hpa,
+            "humidity_percent": humidity_percent,
+            "raw": raw,
+        }

dln2/gpio.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""DLN2 GPIO wrapper."""
+
+from ._core import GPIO_EVENT_NONE, GPIO_EVENT_CHANGE, \
+    GPIO_EVENT_LEVEL_HIGH, GPIO_EVENT_LEVEL_LOW
+
+
+class GPIO:
+    DIRECTION_IN = "in"
+    DIRECTION_OUT = "out"
+
+    def __init__(self, connection=None):
+        if connection is None:
+            from ._core import Dln2Connection
+            connection = Dln2Connection()
+        self._conn = connection
+
+    def get_pin_count(self):
+        return self._conn.gpio_get_pin_count()
+
+    def enable_pin(self, pin):
+        self._conn.gpio_pin_enable(pin)
+
+    def disable_pin(self, pin):
+        self._conn.gpio_pin_disable(pin)
+
+    def set_direction(self, pin, direction):
+        if direction not in (self.DIRECTION_IN, self.DIRECTION_OUT):
+            raise ValueError("direction must be 'in' or 'out'")
+        self._conn.gpio_pin_set_direction(pin, direction == self.DIRECTION_OUT)
+
+    def get_direction(self, pin):
+        is_out = self._conn.gpio_pin_get_direction(pin)
+        return self.DIRECTION_OUT if is_out else self.DIRECTION_IN
+
+    def read(self, pin):
+        return self._conn.gpio_get(pin)
+
+    def write(self, pin, value):
+        self._conn.gpio_set(pin, value)
+
+    def toggle(self, pin):
+        v = self.read_output(pin)
+        new = 0 if v else 1
+        self.write(pin, new)
+        return new
+
+    def read_output(self, pin):
+        return self._conn.gpio_get_out_val(pin)
+
+    def set_event(self, pin, event_type=GPIO_EVENT_CHANGE, period=0):
+        self._conn.gpio_set_event_cfg(pin, event_type, period)
+
+    def clear_event(self, pin):
+        self._conn.gpio_set_event_cfg(pin, GPIO_EVENT_NONE, 0)
+
+    def poll_event(self, timeout_ms=0):
+        return self._conn.gpio_poll_event(timeout_ms)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        pass

dln2/i2c.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""DLN2 SMBus-compatible I2C wrapper."""
+
+
+def _to_bytes(data):
+    if isinstance(data, bytes):
+        return data
+    if isinstance(data, bytearray):
+        return bytes(data)
+    return bytes(int(v) & 0xFF for v in data)
+
+
+class i2c_msg:
+    I2C_M_RD = 0x0001
+
+    def __init__(self, addr, flags, data=b"", length=0):
+        self.addr = int(addr) & 0x7F
+        self.flags = int(flags)
+        self._data = bytes(data)
+        self._length = int(length)
+
+    @classmethod
+    def write(cls, addr, data):
+        payload = _to_bytes(data)
+        return cls(addr, 0, data=payload, length=len(payload))
+
+    @classmethod
+    def read(cls, addr, length):
+        return cls(addr, cls.I2C_M_RD, length=length)
+
+    @property
+    def is_read(self):
+        return bool(self.flags & self.I2C_M_RD)
+
+    @property
+    def len(self):
+        return self._length if self.is_read else len(self._data)
+
+    @property
+    def buf(self):
+        return self._data
+
+    def set_data(self, data):
+        self._data = bytes(data)
+
+
+class SMBus:
+    """SMBus-compatible I2C API backed by Dln2Connection."""
+
+    def __init__(self, connection=None):
+        if connection is None:
+            from ._core import Dln2Connection
+            connection = Dln2Connection()
+        self._conn = connection
+        self._opened = False
+
+    def open(self, bus=0):
+        if self._opened:
+            return
+        self._conn.i2c_enable()
+        self._opened = True
+
+    def close(self):
+        if not self._opened:
+            return
+        try:
+            self._conn.i2c_disable()
+        except Exception:
+            pass
+        self._opened = False
+
+    def _require(self):
+        if not self._opened:
+            self.open()
+        return self._conn
+
+    def enable(self, bus=0):
+        self.open(bus)
+
+    # ── SMBus API ──────────────────────────────────────
+
+    def write_byte(self, addr, value):
+        self._require().i2c_write(addr, [value])
+
+    def write_byte_data(self, addr, cmd, value):
+        self._require().i2c_write(addr, [cmd, value])
+
+    def write_word_data(self, addr, cmd, value):
+        data = [(cmd & 0xFF), (value & 0xFF), ((value >> 8) & 0xFF)]
+        self._require().i2c_write(addr, data)
+
+    def write_block_data(self, addr, cmd, data):
+        payload = [cmd] + list(_to_bytes(data))
+        self._require().i2c_write(addr, payload)
+
+    def write_i2c_block_data(self, addr, cmd, data):
+        self.write_block_data(addr, cmd, data)
+
+    def read_byte(self, addr):
+        return self._require().i2c_read(addr, 1)[0]
+
+    def read_byte_data(self, addr, cmd):
+        return self._require().i2c_read(addr, 1, mem_addr_len=1,
+                                        mem_addr=cmd)[0]
+
+    def read_word_data(self, addr, cmd):
+        rx = self._require().i2c_read(addr, 2, mem_addr_len=1, mem_addr=cmd)
+        return rx[0] | (rx[1] << 8)
+
+    def read_block_data(self, addr, cmd):
+        # Read count byte first, then data
+        count = self._require().i2c_read(addr, 1, mem_addr_len=1,
+                                         mem_addr=cmd)[0]
+        if count == 0:
+            return []
+        return list(self._require().i2c_read(addr, count))
+
+    def read_i2c_block_data(self, addr, cmd, length=32):
+        return list(self._require().i2c_read(addr, length,
+                                             mem_addr_len=1, mem_addr=cmd))
+
+    # ── Raw access ─────────────────────────────────────
+
+    def write(self, addr, data):
+        self._require().i2c_write(addr, data)
+
+    def read(self, addr, length):
+        return self._require().i2c_read(addr, length)
+
+    def __enter__(self):
+        self.open()
+        return self
+
+    def __exit__(self, *a):
+        self.close()

dln2/spi.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""DLN2 SpiDev-compatible SPI wrapper."""
+
+import struct
+import time
+
+
+class SpiDev:
+    """spidev-compatible API backed by a shared Dln2Connection."""
+
+    def __init__(self, connection=None):
+        if connection is None:
+            from ._core import Dln2Connection
+            connection = Dln2Connection()
+        self._conn = connection
+        self.debug = False
+        self._max_speed_hz = 1_000_000
+        self._mode = 0
+        self._bits_per_word = 8
+        self.cshigh = False
+        self.lsbfirst = False
+        self.host_hold_cs = False
+
+    @property
+    def max_speed_hz(self):
+        return self._max_speed_hz
+
+    @max_speed_hz.setter
+    def max_speed_hz(self, v):
+        self._max_speed_hz = int(v)
+
+    @property
+    def mode(self):
+        return self._mode
+
+    @mode.setter
+    def mode(self, v):
+        self._mode = int(v) & 3
+
+    @property
+    def bits_per_word(self):
+        return self._bits_per_word
+
+    @bits_per_word.setter
+    def bits_per_word(self, v):
+        self._bits_per_word = int(v)
+
+    def open(self, bus=0, device=0):
+        """No-op — connection already open. For spidev compatibility."""
+        return self
+
+    def close(self):
+        pass  # connection is shared, caller manages _conn.close()
+
+    def xfer2(self, data):
+        """Full-duplex transfer. Returns MISO data."""
+        bpw = self._bits_per_word
+        if bpw <= 8:
+            tx = bytes(b & 0xFF for b in data)
+        else:
+            out = bytearray()
+            for w in data:
+                out += struct.pack("<H", int(w) & 0xFFFF)
+            tx = bytes(out)
+        return list(self._conn.spi_read_write(
+            tx, leave_ss_low=self.host_hold_cs))
+
+    def xfer(self, data):
+        return self.xfer2(data)
+
+    def writebytes(self, data):
+        self.xfer2(data)
+
+    def readbytes(self, length):
+        return self.xfer2([0] * length)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        pass

dln2-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 IPM Group
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dln2-0.1.0.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.1
+Name: dln2
+Version: 0.1.0
+Summary: Unified DLN2 driver — SPI, GPIO, I2C, ADC over a single USB connection. Originally developed for the Pico USB I/O Board.
+Home-page: https://github.com/syabyr/dln2_wrapper
+Author: IPM Group
+Author-email: contact@ipmgroup.dev
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyusb >=1.2
+
+# dln2 — Unified DLN2 USB I/O Board Wrapper
+
+Drop-in replacement for the four independent `dln2_*_wrapper` packages.  
+**All modules share a single USB connection** — no echo-counter conflicts, no USB contention.
+
+Originally developed for the [Pico USB I/O Board](https://github.com/syabyr/pico-usb-io-board).
+
+## Installation
+
+```bash
+pip install git+https://github.com/syabyr/dln2_wrapper
+```
+
+Requires: `pyusb`
+
+## Quick Start
+
+```python
+from dln2 import Dln2Connection, SpiDev, GPIO, SMBus, ADC
+
+conn = Dln2Connection()          # one USB connection
+
+# ── SPI ─────────────────────────────────────────────────
+spi = SpiDev(conn)
+spi.mode = 3
+spi.max_speed_hz = 16_000_000
+rx = spi.xfer2([0x9F, 0x00, 0x00, 0x00])  # JEDEC ID
+
+# ── GPIO ────────────────────────────────────────────────
+gpio = GPIO(conn)
+gpio.set_direction(20, "out")
+gpio.write(20, 1)                 # set pin HIGH
+val = gpio.read(20)               # read pin level
+
+# ── I2C ─────────────────────────────────────────────────
+i2c = SMBus(conn)
+i2c.open()
+devices = []
+for addr in range(1, 128):
+    try:
+        i2c.write_byte(addr, 0)
+        devices.append(addr)
+    except: pass
+
+# ── ADC ─────────────────────────────────────────────────
+adc = ADC(conn, vref=3.3)
+volts = adc.read_volts(0)         # read channel 0 voltage
+
+conn.close()
+```
+
+## Multi-Device Support
+
+```python
+from dln2 import list_devices, Dln2Connection
+
+for d in list_devices():
+    print(f"[{d.index}] serial={d.serial}")
+
+lcd_conn = Dln2Connection(index=0)     # first board — ST7789 display
+nfc_conn = Dln2Connection(index=1)     # second board — NFC reader
+# or by exact serial:
+# conn = Dln2Connection(serial="4250304B38353817")
+```
+
+## Module API
+
+### SpiDev
+spidev-compatible API: `xfer()`, `xfer2()`, `writebytes()`, `readbytes()`,  
+`mode`, `max_speed_hz`, `bits_per_word`, `cshigh`, `lsbfirst`, `host_hold_cs`
+
+### GPIO
+`set_direction(pin, "in"|"out")`, `write(pin, value)`, `read(pin)`,  
+`toggle(pin)`, `get_direction(pin)`, `set_event(pin, type)`, `poll_event()`
+
+### SMBus
+smbus-compatible API: `write_byte()`, `read_byte_data()`,  
+`write_word_data()`, `read_word_data()`, `read_block_data()`,  
+`write_block_data()`, `write_i2c_block_data()`, `read_i2c_block_data()`
+
+### ADC
+`read_channel(channel)`, `read_all()`, `read_volts(channel)`,  
+`set_resolution(bits)`, `enable_channel(ch)`, `disable_channel(ch)`
+
+### BME280
+`read_chip_id()`, `get_temperature()`, `get_humidity()`, `get_pressure()`,  
+`get_altitude()`, `get_all()`
+
+## Examples
+
+```bash
+# SPI JEDEC ID read
+python3 examples/spidev_test.py
+
+# GPIO pin toggle (default: Pico LED)
+python3 examples/gpio_toggle.py --pin 25
+
+# I2C bus scan
+python3 examples/i2c_scan.py
+
+# ADC monitor
+python3 examples/adc_info.py
+```
+
+## Why Unified?
+
+| | Old (4 packages) | New (`dln2`) |
+|---|---|---|
+| USB connections | 4 separate (echo conflicts) | 1 shared |
+| Code duplication | ~800 lines (4× Dln2Usb) | 0 lines |
+| GPIO events steal SPI responses | Yes | No (proper event queue) |
+| Multi-device | Manual USB enumeration | `list_devices()` |
+| Cross-module data flow | Impossible (4 echo counters) | Trivial (same counter) |
+
+## Related
+
+- [pico-usb-io-board](https://github.com/syabyr/pico-usb-io-board) — RP2040 firmware
+- [st7789 display driver](https://github.com/syabyr/dln2_wrapper) — example ST7789 + BME280 application
+
+## License
+
+MIT

dln2-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+dln2/__init__.py,sha256=Zmp033q4GLszZLBp7k1rdB15rYDx_Rw2F9FzjHBErxs,817
+dln2/_core.py,sha256=7ARFQlst4oAGVT0Yzr41j8v_aujW0eWRkOYMfLU2Bps,22198
+dln2/adc.py,sha256=k8IQSg5Uu0x46kCQoFuVNzZEnvmQ47aISXx_Xic9tVs,2661
+dln2/bme280.py,sha256=Ju2le83bMulC0RG5GKyjPNH5jGNmXI_ApJlsJPqafaY,6515
+dln2/gpio.py,sha256=3zZch84enYorumuELri556Y8E-TK1QBryLX2JuW2Gss,1823
+dln2/i2c.py,sha256=_7Saeg04Aeg_elg_ouaVroj06ra-fL2DUdEhF5mRNPY,3899
+dln2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dln2/spi.py,sha256=-tNn5q1NNcCde3JCed9yyg_r7JI9Z84f1A08KQb5VF8,1999
+dln2-0.1.0.dist-info/LICENSE,sha256=R657Wi0nj-QnCHv5kUQ2_yE1mNwXLNsM5wWQwPE5cas,1066
+dln2-0.1.0.dist-info/METADATA,sha256=FJoHLHPp7gb4I__wf9VNLczbekWBkzus8d_L4ISw7gs,4731
+dln2-0.1.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+dln2-0.1.0.dist-info/top_level.txt,sha256=0_zQFVfHajItivvqoMkbM1HGutiVazNrNd6AjkKaToQ,5
+dln2-0.1.0.dist-info/RECORD,,

dln2-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dln2-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dln2