adafruit-circuitpython-ads7128 1.0.0__py3-none-any.whl

adafruit_ads7128/ads7128.py

@@ -0,0 +1,595 @@
+# SPDX-FileCopyrightText: 2026 Liz Clark for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+"""
+:py:class:`~adafruit_ads7128.ads7128.ADS7128`
+================================================================================
+
+CircuitPython driver for the Adafruit ADS7128 8-Channel ADC and GPIO Expander
+
+* Author(s): Liz Clark
+
+Implementation Notes
+--------------------
+
+**Hardware:**
+
+* `Adafruit ADS7128 8-Channel ADC and GPIO Expander <https://www.adafruit.com/product/6494>`_
+
+**Software and Dependencies:**
+
+* Adafruit CircuitPython firmware for the supported boards:
+  https://circuitpython.org/downloads
+
+* Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice
+"""
+
+import time
+
+from adafruit_bus_device import i2c_device
+from micropython import const
+
+try:
+    from typing import Tuple
+
+    from busio import I2C
+except ImportError:
+    pass
+
+__version__ = "1.0.0"
+__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_ADS7128.git"
+
+# Oversampling ratios
+OSR_NONE = 0
+"""No oversampling (12-bit result)."""
+OSR_2 = 1
+"""2x oversampling (13-bit result)."""
+OSR_4 = 2
+"""4x oversampling (14-bit result)."""
+OSR_8 = 3
+"""8x oversampling (15-bit result)."""
+OSR_16 = 4
+"""16x oversampling (16-bit result)."""
+OSR_32 = 5
+"""32x oversampling (16-bit result)."""
+OSR_64 = 6
+"""64x oversampling (16-bit result)."""
+OSR_128 = 7
+"""128x oversampling (16-bit result)."""
+
+_DEFAULT_ADDR = const(0x10)
+
+# Opcodes
+_OP_READ = const(0x10)
+_OP_WRITE = const(0x08)
+_OP_SET_BIT = const(0x18)
+_OP_CLEAR_BIT = const(0x20)
+
+# Registers
+_STATUS = const(0x00)
+_GENERAL_CFG = const(0x01)
+_DATA_CFG = const(0x02)
+_OSR_CFG = const(0x03)
+_OPMODE_CFG = const(0x04)
+_PIN_CFG = const(0x05)
+_GPIO_CFG = const(0x07)
+_GPO_DRIVE_CFG = const(0x09)
+_GPO_VALUE = const(0x0B)
+_GPI_VALUE = const(0x0D)
+_ZCD_BLANKING_CFG = const(0x0F)
+_SEQUENCE_CFG = const(0x10)
+_CHANNEL_SEL = const(0x11)
+_AUTO_SEQ_CH_SEL = const(0x12)
+_ALERT_CH_SEL = const(0x14)
+_ALERT_PIN_CFG = const(0x17)
+_EVENT_FLAG = const(0x18)
+_EVENT_HIGH_FLAG = const(0x1A)
+_EVENT_LOW_FLAG = const(0x1C)
+_RECENT_LSB_CH0 = const(0xA0)  # +2 per channel
+_RMS_CFG = const(0xC0)
+_RMS_LSB = const(0xC1)
+_RMS_MSB = const(0xC2)
+_GPO_ZCD_UPDATE_EN = const(0xE7)
+
+# SYSTEM_STATUS bits
+_BOR = const(0x01)
+_CRC_ERR_IN = const(0x02)
+_RMS_DONE = const(0x10)
+
+# GENERAL_CFG bits
+_RST = const(0x01)
+_CAL = const(0x02)
+_CNVST = const(0x08)
+_DWC_EN = const(0x10)
+_STATS_EN = const(0x20)
+_CRC_EN = const(0x40)
+_RMS_EN = const(0x80)
+
+# SEQUENCE_CFG bits
+_SEQ_MODE = const(0x01)
+_SEQ_START = const(0x10)
+
+# OPMODE_CFG bits
+_OSC_SEL = const(0x10)
+_CONV_MODE = const(0x20)
+
+# DATA_CFG bits
+_APPEND_CHID = const(0x10)
+
+# ALERT_PIN_CFG bits
+_ALERT_DRIVE = const(0x04)
+
+# ZCD_BLANKING_CFG bits
+_ZCD_MULT = const(0x80)
+
+# RMS_CFG bits
+_RMS_DC_SUB = const(0x04)
+
+
+def _crc8(value: int) -> int:
+    # CRC-8-CCITT, polynomial 0x07, over a single byte
+    crc = value
+    for _ in range(8):
+        if crc & 0x80:
+            crc = ((crc << 1) ^ 0x07) & 0xFF
+        else:
+            crc = (crc << 1) & 0xFF
+    return crc
+
+
+class ADS7128:  # noqa: PLR0904
+    """Driver for the ADS7128 8-channel 12-bit ADC with GPIOs.
+
+    :param ~busio.I2C i2c: The I2C bus the ADS7128 is connected to.
+    :param int address: The I2C address of the device. Defaults to :const:`0x10`.
+    """
+
+    def __init__(self, i2c: "I2C", address: int = _DEFAULT_ADDR) -> None:
+        self.i2c_device = i2c_device.I2CDevice(i2c, address)
+        self._crc_enabled = False
+        self._crc_error = False
+        self._in_buf = bytearray(1)
+        self._out_buf = bytearray(2)
+        self._wbuf = bytearray(3)
+        self._reset()
+
+    def _read_register(self, reg: int) -> int:
+        if self._crc_enabled:
+            out = bytes((_OP_READ, _crc8(_OP_READ), reg, _crc8(reg)))
+            in_buf = bytearray(2)
+            with self.i2c_device as i2c:
+                i2c.write_then_readinto(out, in_buf)
+            if in_buf[1] != _crc8(in_buf[0]):
+                self._crc_error = True
+            return in_buf[0]
+        self._out_buf[0] = _OP_READ
+        self._out_buf[1] = reg
+        with self.i2c_device as i2c:
+            i2c.write_then_readinto(self._out_buf, self._in_buf)
+        return self._in_buf[0]
+
+    def _write_register(self, reg: int, data: int) -> None:
+        if self._crc_enabled:
+            out = bytes((_OP_WRITE, _crc8(_OP_WRITE), reg, _crc8(reg), data, _crc8(data)))
+            with self.i2c_device as i2c:
+                i2c.write(out)
+            return
+        self._wbuf[0] = _OP_WRITE
+        self._wbuf[1] = reg
+        self._wbuf[2] = data
+        with self.i2c_device as i2c:
+            i2c.write(self._wbuf)
+
+    def _set_bits(self, reg: int, mask: int) -> None:
+        if self._crc_enabled:
+            out = bytes((_OP_SET_BIT, _crc8(_OP_SET_BIT), reg, _crc8(reg), mask, _crc8(mask)))
+            with self.i2c_device as i2c:
+                i2c.write(out)
+            return
+        self._wbuf[0] = _OP_SET_BIT
+        self._wbuf[1] = reg
+        self._wbuf[2] = mask
+        with self.i2c_device as i2c:
+            i2c.write(self._wbuf)
+
+    def _clear_bits(self, reg: int, mask: int) -> None:
+        if self._crc_enabled:
+            out = bytes(
+                (
+                    _OP_CLEAR_BIT,
+                    _crc8(_OP_CLEAR_BIT),
+                    reg,
+                    _crc8(reg),
+                    mask,
+                    _crc8(mask),
+                )
+            )
+            with self.i2c_device as i2c:
+                i2c.write(out)
+            return
+        self._wbuf[0] = _OP_CLEAR_BIT
+        self._wbuf[1] = reg
+        self._wbuf[2] = mask
+        with self.i2c_device as i2c:
+            i2c.write(self._wbuf)
+
+    def _read_12bit(self, lsb_reg: int) -> int:
+        # 12-bit value is MSB-aligned across the register pair:
+        # MSB register = [D11:D4], LSB register = [D3:D0, 0, 0, 0, 0]
+        lsb = self._read_register(lsb_reg)
+        msb = self._read_register(lsb_reg + 1)
+        return (msb << 4) | (lsb >> 4)
+
+    def _reset(self) -> None:
+        self._write_register(_GENERAL_CFG, _RST)
+        time.sleep(0.005)
+        self._write_register(_GENERAL_CFG, _CAL)
+        for _ in range(1000):
+            if not self._read_register(_GENERAL_CFG) & _CAL:
+                break
+            time.sleep(0.001)
+        else:
+            raise RuntimeError("ADS7128 calibration timed out")
+        self._write_register(_STATUS, _BOR)
+
+    @staticmethod
+    def _check_channel(channel: int) -> None:
+        if not 0 <= channel <= 7:
+            raise ValueError("channel must be 0-7")
+
+    def _read(self, channel: int) -> int:
+        """Read a single 12-bit conversion (0-4095) from a channel in manual mode.
+
+        :param int channel: Channel number, 0-7.
+        :return: The 12-bit conversion result.
+        :rtype: int
+        """
+        self._check_channel(channel)
+        self._set_bits(_GENERAL_CFG, _STATS_EN)
+        chan_sel = self._read_register(_CHANNEL_SEL)
+        chan_sel = (chan_sel & 0xF0) | (channel & 0x0F)
+        self._write_register(_CHANNEL_SEL, chan_sel)
+        self._set_bits(_GENERAL_CFG, _CNVST)
+        time.sleep(0.00001)
+        return self._read_12bit(_RECENT_LSB_CH0 + channel * 2)
+
+    @property
+    def sequence_channels(self) -> int:
+        """Bitmask of channels included in the auto-sequence (bit 0 = CH0)."""
+        return self._read_register(_AUTO_SEQ_CH_SEL)
+
+    @sequence_channels.setter
+    def sequence_channels(self, channel_mask: int) -> None:
+        self._write_register(_AUTO_SEQ_CH_SEL, channel_mask & 0xFF)
+
+    def start_sequence(self) -> None:
+        """Start autonomous auto-sequence conversions on the selected channels."""
+        self._set_bits(_GENERAL_CFG, _STATS_EN)
+        self._set_bits(_DATA_CFG, _APPEND_CHID)
+        self._set_bits(_OPMODE_CFG, _CONV_MODE)
+        self._write_register(_SEQUENCE_CFG, _SEQ_MODE | _SEQ_START)
+
+    def stop_sequence(self) -> None:
+        """Stop the auto-sequence."""
+        self._clear_bits(_SEQUENCE_CFG, _SEQ_START)
+
+    def read_sequence_result(self) -> "Tuple[int, int]":
+        """Read the next conversion result from the running sequence.
+
+        :return: A ``(value, channel)`` tuple where ``value`` is the 12-bit
+            conversion result and ``channel`` is the channel it came from.
+        :rtype: tuple
+        """
+        out = bytes((_OP_READ, 0x00))
+        in_buf = bytearray(2)
+        with self.i2c_device as i2c:
+            i2c.write_then_readinto(out, in_buf)
+        value = (in_buf[0] << 4) | ((in_buf[1] >> 4) & 0x0F)
+        channel = in_buf[1] & 0x0F
+        return value, channel
+
+    @property
+    def oversampling(self) -> int:
+        """Oversampling ratio (0-7). See the ``OSR_*`` module constants."""
+        return self._read_register(_OSR_CFG) & 0x07
+
+    @oversampling.setter
+    def oversampling(self, osr: int) -> None:
+        if not 0 <= osr <= 7:
+            raise ValueError("oversampling must be 0-7")
+        self._write_register(_OSR_CFG, osr & 0x07)
+
+    @property
+    def pin_cfg(self) -> int:
+        """Per-channel analog (bit clear) / digital (bit set) selection bitmask."""
+        return self._read_register(_PIN_CFG)
+
+    @pin_cfg.setter
+    def pin_cfg(self, value: int) -> None:
+        self._write_register(_PIN_CFG, value & 0xFF)
+
+    @property
+    def gpio_cfg(self) -> int:
+        """Per-channel digital direction bitmask (bit set = output, clear = input)."""
+        return self._read_register(_GPIO_CFG)
+
+    @gpio_cfg.setter
+    def gpio_cfg(self, value: int) -> None:
+        self._write_register(_GPIO_CFG, value & 0xFF)
+
+    @property
+    def gpo_drive_cfg(self) -> int:
+        """Per-channel output drive bitmask (bit set = push-pull, clear = open-drain)."""
+        return self._read_register(_GPO_DRIVE_CFG)
+
+    @gpo_drive_cfg.setter
+    def gpo_drive_cfg(self, value: int) -> None:
+        self._write_register(_GPO_DRIVE_CFG, value & 0xFF)
+
+    @property
+    def gpo_value(self) -> int:
+        """Digital output level bitmask, one bit per channel."""
+        return self._read_register(_GPO_VALUE)
+
+    @gpo_value.setter
+    def gpo_value(self, value: int) -> None:
+        self._write_register(_GPO_VALUE, value & 0xFF)
+
+    @property
+    def gpi_value(self) -> int:
+        """Digital input level bitmask, one bit per channel. (read-only)"""
+        return self._read_register(_GPI_VALUE)
+
+    @property
+    def gpo_zcd_update_en(self) -> int:
+        """Per-channel zero-crossing-to-GPO update enable bitmask."""
+        return self._read_register(_GPO_ZCD_UPDATE_EN)
+
+    @gpo_zcd_update_en.setter
+    def gpo_zcd_update_en(self, value: int) -> None:
+        self._write_register(_GPO_ZCD_UPDATE_EN, value & 0xFF)
+
+    @property
+    def crc_enabled(self) -> bool:
+        """Whether CRC validation of I2C transactions is enabled."""
+        return self._crc_enabled
+
+    @crc_enabled.setter
+    def crc_enabled(self, enable: bool) -> None:
+        if enable:
+            self._set_bits(_GENERAL_CFG, _CRC_EN)
+            self._crc_enabled = True
+        else:
+            self._clear_bits(_GENERAL_CFG, _CRC_EN)
+            self._crc_enabled = False
+
+    @property
+    def crc_error(self) -> bool:
+        """``True`` if a CRC error has been detected on the I2C interface. (read-only)"""
+        if self._read_register(_STATUS) & _CRC_ERR_IN:
+            return True
+        return self._crc_error
+
+    def clear_crc_error(self) -> None:
+        """Clear the CRC error flag."""
+        self._crc_error = False
+        self._write_register(_STATUS, _CRC_ERR_IN)
+
+    @property
+    def statistics_enabled(self) -> bool:
+        """Whether min/max/recent statistics tracking is enabled."""
+        return bool(self._read_register(_GENERAL_CFG) & _STATS_EN)
+
+    @statistics_enabled.setter
+    def statistics_enabled(self, enable: bool) -> None:
+        if enable:
+            self._set_bits(_GENERAL_CFG, _STATS_EN)
+        else:
+            self._clear_bits(_GENERAL_CFG, _STATS_EN)
+
+    def reset_statistics(self) -> None:
+        """Clear all recorded statistics and restart recording."""
+        self._clear_bits(_GENERAL_CFG, _STATS_EN)
+        self._set_bits(_GENERAL_CFG, _STATS_EN)
+
+    @property
+    def dwc_enabled(self) -> bool:
+        """Whether the digital window comparator is enabled."""
+        return bool(self._read_register(_GENERAL_CFG) & _DWC_EN)
+
+    @dwc_enabled.setter
+    def dwc_enabled(self, enable: bool) -> None:
+        if enable:
+            self._set_bits(_GENERAL_CFG, _DWC_EN)
+        else:
+            self._clear_bits(_GENERAL_CFG, _DWC_EN)
+
+    @property
+    def event_flags(self) -> int:
+        """Combined high/low threshold event flags, one bit per channel. (read-only)"""
+        return self._read_register(_EVENT_FLAG)
+
+    @property
+    def event_high_flags(self) -> int:
+        """High threshold event flags, one bit per channel. (read-only)"""
+        return self._read_register(_EVENT_HIGH_FLAG)
+
+    @property
+    def event_low_flags(self) -> int:
+        """Low threshold event flags, one bit per channel. (read-only)"""
+        return self._read_register(_EVENT_LOW_FLAG)
+
+    def clear_event_flags(self) -> None:
+        """Clear all high and low threshold event flags."""
+        self._write_register(_EVENT_HIGH_FLAG, 0xFF)
+        self._write_register(_EVENT_LOW_FLAG, 0xFF)
+
+    @property
+    def alert_push_pull(self) -> bool:
+        """ALERT pin drive: ``True`` for push-pull, ``False`` for open-drain."""
+        return bool(self._read_register(_ALERT_PIN_CFG) & _ALERT_DRIVE)
+
+    @alert_push_pull.setter
+    def alert_push_pull(self, value: bool) -> None:
+        cfg = self._read_register(_ALERT_PIN_CFG)
+        if value:
+            cfg |= _ALERT_DRIVE
+        else:
+            cfg &= ~_ALERT_DRIVE & 0xFF
+        self._write_register(_ALERT_PIN_CFG, cfg)
+
+    @property
+    def alert_logic(self) -> int:
+        """ALERT pin logic: 0=active low, 1=active high, 2=pulsed low, 3=pulsed high."""
+        return self._read_register(_ALERT_PIN_CFG) & 0x03
+
+    @alert_logic.setter
+    def alert_logic(self, value: int) -> None:
+        if not 0 <= value <= 3:
+            raise ValueError("alert_logic must be 0-3")
+        cfg = self._read_register(_ALERT_PIN_CFG)
+        cfg = (cfg & ~0x03 & 0xFF) | value
+        self._write_register(_ALERT_PIN_CFG, cfg)
+
+    @property
+    def alert_channels(self) -> int:
+        """Bitmask of channels that can trigger the ALERT pin (bit 0 = CH0)."""
+        return self._read_register(_ALERT_CH_SEL)
+
+    @alert_channels.setter
+    def alert_channels(self, channel_mask: int) -> None:
+        self._write_register(_ALERT_CH_SEL, channel_mask & 0xFF)
+
+    @property
+    def low_power_oscillator(self) -> bool:
+        """Use the low-power oscillator (``True``) or high-speed oscillator (``False``)."""
+        return bool(self._read_register(_OPMODE_CFG) & _OSC_SEL)
+
+    @low_power_oscillator.setter
+    def low_power_oscillator(self, value: bool) -> None:
+        cfg = self._read_register(_OPMODE_CFG)
+        if value:
+            cfg |= _OSC_SEL
+        else:
+            cfg &= ~_OSC_SEL & 0xFF
+        self._write_register(_OPMODE_CFG, cfg)
+
+    @property
+    def clock_divider(self) -> int:
+        """Autonomous-mode sampling clock divider, 0-15."""
+        return self._read_register(_OPMODE_CFG) & 0x0F
+
+    @clock_divider.setter
+    def clock_divider(self, divider: int) -> None:
+        if not 0 <= divider <= 15:
+            raise ValueError("clock_divider must be 0-15")
+        cfg = self._read_register(_OPMODE_CFG)
+        cfg = (cfg & 0xF0) | (divider & 0x0F)
+        self._write_register(_OPMODE_CFG, cfg)
+
+    @property
+    def zcd_channel(self) -> int:
+        """Analog channel monitored by the zero-crossing detector, 0-7."""
+        return (self._read_register(_CHANNEL_SEL) >> 4) & 0x0F
+
+    @zcd_channel.setter
+    def zcd_channel(self, channel: int) -> None:
+        self._check_channel(channel)
+        reg = self._read_register(_CHANNEL_SEL)
+        reg = (reg & 0x0F) | (channel << 4)
+        self._write_register(_CHANNEL_SEL, reg)
+
+    @property
+    def zcd_blanking(self) -> int:
+        """Zero-crossing blanking count, 0-127 (conversions skipped after an event)."""
+        return self._read_register(_ZCD_BLANKING_CFG) & 0x7F
+
+    @zcd_blanking.setter
+    def zcd_blanking(self, count: int) -> None:
+        if not 0 <= count <= 127:
+            raise ValueError("zcd_blanking must be 0-127")
+        reg = self._read_register(_ZCD_BLANKING_CFG)
+        reg = (reg & _ZCD_MULT) | (count & 0x7F)
+        self._write_register(_ZCD_BLANKING_CFG, reg)
+
+    @property
+    def zcd_blanking_multiply(self) -> bool:
+        """When ``True``, the zero-crossing blanking count is multiplied by 8."""
+        return bool(self._read_register(_ZCD_BLANKING_CFG) & _ZCD_MULT)
+
+    @zcd_blanking_multiply.setter
+    def zcd_blanking_multiply(self, value: bool) -> None:
+        reg = self._read_register(_ZCD_BLANKING_CFG)
+        if value:
+            reg |= _ZCD_MULT
+        else:
+            reg &= ~_ZCD_MULT & 0xFF
+        self._write_register(_ZCD_BLANKING_CFG, reg)
+
+    @property
+    def rms_enabled(self) -> bool:
+        """Whether the RMS computation module is enabled.
+
+        Setting this to ``True`` clears any previous result and starts a new
+        computation using samples from autonomous conversion mode.
+        """
+        return bool(self._read_register(_GENERAL_CFG) & _RMS_EN)
+
+    @rms_enabled.setter
+    def rms_enabled(self, enable: bool) -> None:
+        if enable:
+            self._set_bits(_GENERAL_CFG, _RMS_EN)
+        else:
+            self._clear_bits(_GENERAL_CFG, _RMS_EN)
+
+    @property
+    def rms_channel(self) -> int:
+        """Analog channel the RMS module monitors, 0-7."""
+        return (self._read_register(_RMS_CFG) >> 4) & 0x0F
+
+    @rms_channel.setter
+    def rms_channel(self, channel: int) -> None:
+        self._check_channel(channel)
+        reg = self._read_register(_RMS_CFG)
+        reg = (reg & 0x0F) | (channel << 4)
+        self._write_register(_RMS_CFG, reg)
+
+    @property
+    def rms_samples(self) -> int:
+        """RMS sample-count setting: 0=1024, 1=4096, 2=16384, 3=65536 samples."""
+        return self._read_register(_RMS_CFG) & 0x03
+
+    @rms_samples.setter
+    def rms_samples(self, setting: int) -> None:
+        if not 0 <= setting <= 3:
+            raise ValueError("rms_samples must be 0-3")
+        reg = self._read_register(_RMS_CFG)
+        reg = (reg & 0xFC) | (setting & 0x03)
+        self._write_register(_RMS_CFG, reg)
+
+    @property
+    def rms_dc_subtract(self) -> bool:
+        """Whether the DC component is subtracted before the RMS calculation."""
+        return bool(self._read_register(_RMS_CFG) & _RMS_DC_SUB)
+
+    @rms_dc_subtract.setter
+    def rms_dc_subtract(self, enable: bool) -> None:
+        if enable:
+            self._set_bits(_RMS_CFG, _RMS_DC_SUB)
+        else:
+            self._clear_bits(_RMS_CFG, _RMS_DC_SUB)
+
+    @property
+    def rms(self) -> int:
+        """The 16-bit RMS result over the configured number of samples. (read-only)"""
+        lsb = self._read_register(_RMS_LSB)
+        msb = self._read_register(_RMS_MSB)
+        return (msb << 8) | lsb
+
+    @property
+    def rms_done(self) -> bool:
+        """``True`` if the RMS computation is complete. Reading clears the flag. (read-only)"""
+        if self._read_register(_STATUS) & _RMS_DONE:
+            self._set_bits(_STATUS, _RMS_DONE)
+            return True
+        return False

adafruit_ads7128/analog_in.py

@@ -0,0 +1,167 @@
+# SPDX-FileCopyrightText: 2026 Liz Clark for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+"""
+:py:class:`~adafruit_ads7128.analog_in.AnalogIn`
+======================================================
+AnalogIn for ADC readings.
+
+* Author(s): Liz Clark
+
+"""
+
+from micropython import const
+
+from adafruit_ads7128.ads7128 import ADS7128
+
+__version__ = "1.0.0"
+__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_ADS7128.git"
+
+_EVENT_RGN = const(0x1E)
+_HYSTERESIS_CH0 = const(0x20)  # per-channel block base, +4 per channel
+_MAX_LSB_CH0 = const(0x60)  # +2 per channel
+_MIN_LSB_CH0 = const(0x80)
+_RECENT_LSB_CH0 = const(0xA0)  # +2 per channel
+
+
+class AnalogIn:
+    """AnalogIn-compatible wrapper for ADS7128 single-ended readings.
+
+    Provides a :attr:`value` property scaled to a 16-bit unsigned range
+    ``[0, 65535]`` and a :attr:`voltage` property in volts, matching the
+    CircuitPython ``analogio.AnalogIn`` API.
+
+    :param ADS7128 adc: The ADS7128 driver instance.
+    :param int pin: Channel number (0-7).
+    """
+
+    def __init__(self, adc: ADS7128, pin: int) -> None:
+        if not isinstance(adc, ADS7128):
+            raise ValueError("adc must be an ADS7128 instance")
+        if pin < 0 or pin > 7:
+            raise ValueError("pin must be 0-7")
+        self._adc = adc
+        self._pin = pin
+        adc.pin_cfg = adc.pin_cfg & ~(1 << pin) & 0xFF
+
+    @property
+    def value(self) -> int:
+        """ADC reading as an unsigned 16-bit integer in the range ``[0, 65535]``.
+
+        The 12-bit conversion result is scaled to 16 bits to match the
+        ``analogio.AnalogIn`` API.
+        """
+        raw = self._adc._read(self._pin)
+        return min((raw * 65535) // 4095, 65535)
+
+    def voltage(self, reference_voltage: float = 5.0) -> float:
+        """Read the channel and convert the result to volts.
+
+        :param float reference_voltage: ADC reference voltage in volts.
+            Defaults to :const:`5.0` to match the device's default reference.
+        :return: The measured voltage in volts.
+        :rtype: float
+        """
+        return (self._adc._read(self._pin) / 4096.0) * reference_voltage
+
+    @property
+    def max(self) -> int:
+        """Maximum value recorded on this channel, in 12-bit counts. (read-only)
+
+        Requires :attr:`ADS7128.statistics_enabled` to be ``True``.
+        """
+        return self._adc._read_12bit(_MAX_LSB_CH0 + self._pin * 2)
+
+    @property
+    def min(self) -> int:
+        """Minimum value recorded on this channel, in 12-bit counts. (read-only)
+
+        Requires :attr:`ADS7128.statistics_enabled` to be ``True``.
+        """
+        return self._adc._read_12bit(_MIN_LSB_CH0 + self._pin * 2)
+
+    @property
+    def recent(self) -> int:
+        """Most recent conversion recorded on this channel, in 12-bit counts. (read-only)
+
+        Requires :attr:`ADS7128.statistics_enabled` to be ``True``.
+        """
+        return self._adc._read_12bit(_RECENT_LSB_CH0 + self._pin * 2)
+
+    @property
+    def high_threshold(self) -> int:
+        """Window-comparator high threshold for this channel, in 12-bit counts (0-4095)."""
+        base = _HYSTERESIS_CH0 + self._pin * 4
+        msb = self._adc._read_register(base + 1)
+        hyst = self._adc._read_register(base)
+        return (msb << 4) | ((hyst >> 4) & 0x0F)
+
+    @high_threshold.setter
+    def high_threshold(self, value: int) -> None:
+        if not 0 <= value <= 0x0FFF:
+            raise ValueError("high_threshold must be 0-4095")
+        base = _HYSTERESIS_CH0 + self._pin * 4
+        self._adc._write_register(base + 1, (value >> 4) & 0xFF)
+        hyst = self._adc._read_register(base)
+        hyst = (hyst & 0x0F) | ((value & 0x0F) << 4)
+        self._adc._write_register(base, hyst)
+
+    @property
+    def low_threshold(self) -> int:
+        """Window-comparator low threshold for this channel, in 12-bit counts (0-4095)."""
+        base = _HYSTERESIS_CH0 + self._pin * 4
+        msb = self._adc._read_register(base + 3)
+        evt = self._adc._read_register(base + 2)
+        return (msb << 4) | ((evt >> 4) & 0x0F)
+
+    @low_threshold.setter
+    def low_threshold(self, value: int) -> None:
+        if not 0 <= value <= 0x0FFF:
+            raise ValueError("low_threshold must be 0-4095")
+        base = _HYSTERESIS_CH0 + self._pin * 4
+        self._adc._write_register(base + 3, (value >> 4) & 0xFF)
+        evt = self._adc._read_register(base + 2)
+        evt = (evt & 0x0F) | ((value & 0x0F) << 4)
+        self._adc._write_register(base + 2, evt)
+
+    @property
+    def hysteresis(self) -> int:
+        """Window-comparator hysteresis for this channel, 0-15."""
+        return self._adc._read_register(_HYSTERESIS_CH0 + self._pin * 4) & 0x0F
+
+    @hysteresis.setter
+    def hysteresis(self, value: int) -> None:
+        if not 0 <= value <= 15:
+            raise ValueError("hysteresis must be 0-15")
+        base = _HYSTERESIS_CH0 + self._pin * 4
+        reg = self._adc._read_register(base)
+        reg = (reg & 0xF0) | (value & 0x0F)
+        self._adc._write_register(base, reg)
+
+    @property
+    def event_region(self) -> bool:
+        """Comparator event region: ``True`` for in-band, ``False`` for out-of-window."""
+        return bool(self._adc._read_register(_EVENT_RGN) & (1 << self._pin))
+
+    @event_region.setter
+    def event_region(self, in_band: bool) -> None:
+        if in_band:
+            self._adc._set_bits(_EVENT_RGN, 1 << self._pin)
+        else:
+            self._adc._clear_bits(_EVENT_RGN, 1 << self._pin)
+
+    @property
+    def event_count(self) -> int:
+        """Consecutive samples before an alert triggers, 0-15 (alert after count + 1)."""
+        base = _HYSTERESIS_CH0 + self._pin * 4
+        return self._adc._read_register(base + 2) & 0x0F
+
+    @event_count.setter
+    def event_count(self, count: int) -> None:
+        if not 0 <= count <= 15:
+            raise ValueError("event_count must be 0-15")
+        base = _HYSTERESIS_CH0 + self._pin * 4
+        evt = self._adc._read_register(base + 2)
+        evt = (evt & 0xF0) | (count & 0x0F)
+        self._adc._write_register(base + 2, evt)

adafruit_ads7128/digital_inout.py

@@ -0,0 +1,188 @@
+# SPDX-FileCopyrightText: 2026 Liz Clark for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+"""
+:py:class:`~adafruit_ads7128.digital_inout.DigitalInOut`
+==============================================================
+
+Digital input/output of the ADS7128.
+
+* Author(s): Liz Clark
+
+"""
+
+import digitalio
+from micropython import const
+
+from adafruit_ads7128.ads7128 import ADS7128
+
+try:
+    from typing import Optional
+
+    from digitalio import Direction, DriveMode, Pull
+except ImportError:
+    pass
+
+__version__ = "1.0.0"
+__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_ADS7128.git"
+
+
+_ZCD_CFG_CH0_3 = const(0xE3)
+_ZCD_CFG_CH4_7 = const(0xE4)
+
+
+def _get_bit(val: int, bit: int) -> bool:
+    return val & (1 << bit) > 0
+
+
+def _enable_bit(val: int, bit: int) -> int:
+    return val | (1 << bit)
+
+
+def _clear_bit(val: int, bit: int) -> int:
+    return val & ~(1 << bit) & 0xFF
+
+
+class DigitalInOut:
+    """Digital input/output of the ADS7128. The interface is the same as the
+    ``digitalio.DigitalInOut`` class, however:
+
+      * the ADS7128 does not support pull-up or pull-down resistors;
+      * a channel used here is taken out of analog mode.
+
+    Open-drain outputs are supported through :attr:`drive_mode`. A
+    :exc:`ValueError` is raised when attempting to set an unsupported pull
+    configuration.
+
+    :param ADS7128 adc: The ADS7128 driver instance.
+    :param int pin: Channel number (0-7).
+    """
+
+    def __init__(self, adc: ADS7128, pin: int) -> None:
+        if not isinstance(adc, ADS7128):
+            raise ValueError("adc must be an ADS7128 instance")
+        if pin < 0 or pin > 7:
+            raise ValueError("pin must be 0-7")
+        self._adc = adc
+        self._pin = pin
+
+    def switch_to_output(
+        self,
+        value: bool = False,
+        drive_mode: "DriveMode" = digitalio.DriveMode.PUSH_PULL,
+        **kwargs,
+    ) -> None:
+        """Switch the pin to a digital output with the given starting value and
+        drive mode (push-pull by default).
+
+        :param bool value: Initial output level. Defaults to ``False`` (low).
+        :param ~digitalio.DriveMode drive_mode: Output drive mode.
+        """
+        self.direction = digitalio.Direction.OUTPUT
+        self.drive_mode = drive_mode
+        self.value = value
+
+    def switch_to_input(self, pull: "Pull" = None, **kwargs) -> None:
+        """Switch the pin to a digital input.
+
+        :param ~digitalio.Pull pull: Must be ``None``; pull resistors are not
+            supported and any other value raises :exc:`ValueError`.
+        """
+        self.direction = digitalio.Direction.INPUT
+        self.pull = pull
+
+    @property
+    def value(self) -> bool:
+        """The value of the pin, either ``True`` for high or ``False`` for low.
+
+        Configure the pin as an output or input before writing or reading this.
+        """
+        if _get_bit(self._adc.gpio_cfg, self._pin):
+            return _get_bit(self._adc.gpo_value, self._pin)
+        return _get_bit(self._adc.gpi_value, self._pin)
+
+    @value.setter
+    def value(self, val: bool) -> None:
+        if val:
+            self._adc.gpo_value = _enable_bit(self._adc.gpo_value, self._pin)
+        else:
+            self._adc.gpo_value = _clear_bit(self._adc.gpo_value, self._pin)
+
+    @property
+    def direction(self) -> "Direction":
+        """The direction of the pin, either ``digitalio.Direction.INPUT`` or
+        ``digitalio.Direction.OUTPUT``.
+        """
+        if _get_bit(self._adc.gpio_cfg, self._pin):
+            return digitalio.Direction.OUTPUT
+        return digitalio.Direction.INPUT
+
+    @direction.setter
+    def direction(self, val: "Direction") -> None:
+        self._adc.pin_cfg = _enable_bit(self._adc.pin_cfg, self._pin)
+        if val == digitalio.Direction.INPUT:
+            self._adc.gpio_cfg = _clear_bit(self._adc.gpio_cfg, self._pin)
+        elif val == digitalio.Direction.OUTPUT:
+            self._adc.gpio_cfg = _enable_bit(self._adc.gpio_cfg, self._pin)
+        else:
+            raise ValueError("Expected INPUT or OUTPUT direction!")
+
+    @property
+    def drive_mode(self) -> "DriveMode":
+        """The output drive mode, either ``digitalio.DriveMode.PUSH_PULL`` or
+        ``digitalio.DriveMode.OPEN_DRAIN``.
+        """
+        if _get_bit(self._adc.gpo_drive_cfg, self._pin):
+            return digitalio.DriveMode.PUSH_PULL
+        return digitalio.DriveMode.OPEN_DRAIN
+
+    @drive_mode.setter
+    def drive_mode(self, val: "DriveMode") -> None:
+        if val == digitalio.DriveMode.PUSH_PULL:
+            self._adc.gpo_drive_cfg = _enable_bit(self._adc.gpo_drive_cfg, self._pin)
+        elif val == digitalio.DriveMode.OPEN_DRAIN:
+            self._adc.gpo_drive_cfg = _clear_bit(self._adc.gpo_drive_cfg, self._pin)
+        else:
+            raise ValueError("Expected PUSH_PULL or OPEN_DRAIN drive mode!")
+
+    @property
+    def zcd_output(self) -> int:
+        """Zero-crossing-detector output mode mapped onto this GPO pin.
+
+        0=low, 1=high, 2=ZCD signal, 3=inverted ZCD. Use with
+        :attr:`zcd_output_enabled`.
+        """
+        if self._pin < 4:
+            reg = _ZCD_CFG_CH0_3
+            shift = self._pin * 2
+        else:
+            reg = _ZCD_CFG_CH4_7
+            shift = (self._pin - 4) * 2
+        return (self._adc._read_register(reg) >> shift) & 0x03
+
+    @zcd_output.setter
+    def zcd_output(self, mode: int) -> None:
+        if not 0 <= mode <= 3:
+            raise ValueError("zcd_output must be 0-3")
+        if self._pin < 4:
+            reg = _ZCD_CFG_CH0_3
+            shift = self._pin * 2
+        else:
+            reg = _ZCD_CFG_CH4_7
+            shift = (self._pin - 4) * 2
+        val = self._adc._read_register(reg)
+        val = (val & ~(0x03 << shift) & 0xFF) | (mode << shift)
+        self._adc._write_register(reg, val)
+
+    @property
+    def zcd_output_enabled(self) -> bool:
+        """Whether the zero-crossing detector drives this GPO pin."""
+        return _get_bit(self._adc.gpo_zcd_update_en, self._pin)
+
+    @zcd_output_enabled.setter
+    def zcd_output_enabled(self, value: bool) -> None:
+        if value:
+            self._adc.gpo_zcd_update_en = _enable_bit(self._adc.gpo_zcd_update_en, self._pin)
+        else:
+            self._adc.gpo_zcd_update_en = _clear_bit(self._adc.gpo_zcd_update_en, self._pin)

adafruit_circuitpython_ads7128-1.0.0.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: adafruit-circuitpython-ads7128
+Version: 1.0.0
+Summary: CircuitPython driver for the Adafruit ADS7128 8-Channel ADC and GPIO Expander
+Author-email: Adafruit Industries <circuitpython@adafruit.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/adafruit/Adafruit_CircuitPython_ADS7128
+Keywords: adafruit,blinka,circuitpython,micropython,ads7128,ADC,,GPIO,expander
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Topic :: System :: Hardware
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: Adafruit-Blinka
+Requires-Dist: adafruit-circuitpython-busdevice
+Requires-Dist: adafruit-circuitpython-register
+Provides-Extra: optional
+Dynamic: license-file
+
+Introduction
+============
+
+
+.. image:: https://readthedocs.org/projects/adafruit-circuitpython-ads7128/badge/?version=latest
+    :target: https://docs.circuitpython.org/projects/ads7128/en/latest/
+    :alt: Documentation Status
+
+
+.. image:: https://raw.githubusercontent.com/adafruit/Adafruit_CircuitPython_Bundle/main/badges/adafruit_discord.svg
+    :target: https://adafru.it/discord
+    :alt: Discord
+
+
+.. image:: https://github.com/adafruit/Adafruit_CircuitPython_ADS7128/workflows/Build%20CI/badge.svg
+    :target: https://github.com/adafruit/Adafruit_CircuitPython_ADS7128/actions
+    :alt: Build Status
+
+
+.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
+    :target: https://github.com/astral-sh/ruff
+    :alt: Code Style: Ruff
+
+CircuitPython driver for the Adafruit ADS7128 8-Channel ADC and GPIO Expander
+
+
+Dependencies
+=============
+This driver depends on:
+
+* `Adafruit CircuitPython <https://github.com/adafruit/circuitpython>`_
+* `Bus Device <https://github.com/adafruit/Adafruit_CircuitPython_BusDevice>`_
+* `Register <https://github.com/adafruit/Adafruit_CircuitPython_Register>`_
+
+Please ensure all dependencies are available on the CircuitPython filesystem.
+This is easily achieved by downloading
+`the Adafruit library and driver bundle <https://circuitpython.org/libraries>`_
+or individual libraries can be installed using
+`circup <https://github.com/adafruit/circup>`_.
+
+`Purchase one from the Adafruit shop <http://www.adafruit.com/products/6494>`_
+
+Installing from PyPI
+=====================
+
+On supported GNU/Linux systems like the Raspberry Pi, you can install the driver locally `from
+PyPI <https://pypi.org/project/adafruit-circuitpython-ads7128/>`_.
+To install for current user:
+
+.. code-block:: shell
+
+    pip3 install adafruit-circuitpython-ads7128
+
+To install system-wide (this may be required in some cases):
+
+.. code-block:: shell
+
+    sudo pip3 install adafruit-circuitpython-ads7128
+
+To install in a virtual environment in your current project:
+
+.. code-block:: shell
+
+    mkdir project-name && cd project-name
+    python3 -m venv .venv
+    source .env/bin/activate
+    pip3 install adafruit-circuitpython-ads7128
+
+Installing to a Connected CircuitPython Device with Circup
+==========================================================
+
+Make sure that you have ``circup`` installed in your Python environment.
+Install it with the following command if necessary:
+
+.. code-block:: shell
+
+    pip3 install circup
+
+With ``circup`` installed and your CircuitPython device connected use the
+following command to install:
+
+.. code-block:: shell
+
+    circup install adafruit_ads7128
+
+Or the following command to update an existing version:
+
+.. code-block:: shell
+
+    circup update
+
+Usage Example
+=============
+
+.. code-block:: python
+
+    import time
+
+    import board
+
+    from adafruit_ads7128.ads7128 import ADS7128
+    from adafruit_ads7128.analog_in import AnalogIn
+
+    REFERENCE_VOLTAGE = 3.3
+
+    i2c = board.I2C()
+    adc = ADS7128(i2c)
+    channel = AnalogIn(adc, 0)
+
+    while True:
+        print(f"value: {channel.value}  voltage: {channel.voltage(REFERENCE_VOLTAGE):.3f} V")
+        time.sleep(1.0)
+
+Documentation
+=============
+API documentation for this library can be found on `Read the Docs <https://docs.circuitpython.org/projects/ads7128/en/latest/>`_.
+
+For information on building library documentation, please check out
+`this guide <https://learn.adafruit.com/creating-and-sharing-a-circuitpython-library/sharing-our-docs-on-readthedocs#sphinx-5-1>`_.
+
+Contributing
+============
+
+Contributions are welcome! Please read our `Code of Conduct
+<https://github.com/adafruit/Adafruit_CircuitPython_ADS7128/blob/HEAD/CODE_OF_CONDUCT.md>`_
+before contributing to help this project stay welcoming.

adafruit_circuitpython_ads7128-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+adafruit_ads7128/ads7128.py,sha256=Gqra7hlDzWPXs1MGMyerz8VzygFLVvB7tCB6h-DmG-0,19505
+adafruit_ads7128/analog_in.py,sha256=bhJRRHnISrIAOjEparXZjFOCvxac7r2p2I5AaWWBNU0,6094
+adafruit_ads7128/digital_inout.py,sha256=qndR0Sygo3rDyN9N2AOXq13kfRdiOjPsSgaBS1mCI-U,6301
+adafruit_circuitpython_ads7128-1.0.0.dist-info/licenses/LICENSE,sha256=0JsO0yQOspYeKuhk2Y_s1wan9NO0DYeWSRJBrYJdeko,1100
+adafruit_circuitpython_ads7128-1.0.0.dist-info/METADATA,sha256=Kh0jl5eh5LDYsvLqQRrR_S8IG4Akc5TtlmnTRczbpVw,4695
+adafruit_circuitpython_ads7128-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+adafruit_circuitpython_ads7128-1.0.0.dist-info/top_level.txt,sha256=lYnOESNlST-F5z_4I2LlQ-n58vkuWz4UhKIkFpbyohI,17
+adafruit_circuitpython_ads7128-1.0.0.dist-info/RECORD,,

adafruit_circuitpython_ads7128-1.0.0.dist-info/WHEEL

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

adafruit_circuitpython_ads7128-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Liz Clark for Adafruit Industries
+
+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.

adafruit_circuitpython_ads7128-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+adafruit_ads7128