ADS7128: el chip híbrido ADC + expansor GPIO por I2C que combina 8 canales configurables en uno

Cuando tu ESP32 se queda sin pines analógicos y tienes que leer cuatro sensores más, la respuesta típica es agregar un ADS1115 (4 canales ADC I2C). ¿Pero qué pasa si además de ADC necesitás pines de I/O digitales configurables, medición RMS integrada, detección de threshold con alerta por interrupción y posibilidad de mezclar canales analógicos con digitales en el mismo chip? Ahí entra el ADS7128, un chip Texas Instruments que Adafruit encapsuló en un breakout con conector STEMMA QT y soporta CircuitPython + Arduino.

Al terminar este tutorial vas a saber por qué el ADS7128 es "raro" en el ecosistema I2C, cómo conectarlo a un microcontrolador de 3.3 o 5 V, cómo leer sus 8 canales desde CircuitPython y Arduino, y cuándo conviene sobre alternativas más comunes como el ADS1115 + PCF8574 combinados.

El problema que resuelve el ADS7128

Los expansores I2C tradicionales se dividen en dos categorías bien separadas:

• ADC (Analog to-Digital Converter): chips como el ADS1115 (16-bit, 4 canales), MCP3008 (10-bit, 8 canales SPI), MAX11615. Solo convierten voltaje analógico a números.
• GPIO expanders: chips como el PCF8574 (8 pines digitales), MCP23017 (16 pines), TCA9535. Solo dan pines digitales de entrada/salida.

Si tu proyecto necesita las dos cosas. por ejemplo, un panel de control con potenciómetros analógicos y botones/LEDs digitales. tienes que soldar los dos chips en la misma bus I2C. Funciona, pero suma dos direcciones, dos librerías y dos footprints en el PCB.

El ADS7128 es un chip Texas Instruments que integra las dos funciones. Sus 8 pines son individualmente configurables como:

• Entrada analógica de 12-bit SAR (por canal, hasta 8 en paralelo)
• Salida digital push pull
• Salida digital open drain
• Entrada digital

Todo dentro de un mismo chip, con una sola dirección I2C, una sola librería. Adafruit lo bautizó "el ornitorrinco de los expansores I2C" precisamente por ser este raro híbrido.

Qué trae de más el chip (features avanzadas)

Además del combo ADC + GPIO, el ADS7128 tiene extras que un chip "básico" no traería:

• Modo standalone con detección de cruce por cero: útil para detectar señales AC.
• Cómputo de RMS en hardware: podes medir valor eficaz de una señal sin hacerlo por software.
• Contador de cruces de umbral: te avisa (interrupción) cuando la entrada pasa un valor configurable.
• Pin de alerta dedicado (ALRT): dispara sin polling I2C cuando algo interesante ocurre.
• Dos supplies separados (DVDD y AVDD): podes tener lógica digital de 3.3 V con analógica de 5 V (o al revés). Muy útil cuando tu MCU es 3.3 V pero quieres medir señales referenciadas a 5 V con máximo margen dinámico.

Comparado con un ADS1115 (que es el go to en Chile por precio y stock), la resolución del ADS7128 es menor (12-bit vs 16-bit) y no tiene PGA programable. Pero para casos donde el volumen de pines pesa más que 4 bits de resolución, gana.

Materiales

• Breakout Adafruit ADS7128 (P/N 6494 - $14.95 USD). Es el componente central; no tiene equivalente clon directo por ahora.
• Microcontrolador CircuitPython o Arduino con I2C: Feather RP2040, Metro M4, Raspberry Pi Pico, ESP32, Arduino Uno... cualquiera funciona. Para pruebas: Adafruit Feather RP2040 o Arduino Uno R3.
• Cable STEMMA QT / Qwiic de 50 o 100 mm (Adafruit tiene varios largos: JST SH 4-pin). Alternativa: cables Dupont si vas a soldar los headers.
• Potenciómetro 10 kΩ lineal (para probar la lectura ADC). El de Adafruit trae perilla; cualquier potenciómetro rotativo de 10K sirve.
• Protoboard 830 puntos (si no usas STEMMA QT).
• Cables jumper Dupont macho macho (para conexiones al pot).
• Fuente 3.3 V o 5 V (viene por USB del MCU).

Pinout del breakout (todo lo que tienes que saber)

Alimentación

• VIN: 3.3 a 5.0 VDC. Dale la misma tensión que la lógica de tu MCU (5 V para Arduino Uno, 3.3 V para ESP32/Feather/RP2040).
• AVDD: referencia analógica. Por defecto está puenteada a VIN.
• AVDD Jumper: si cortás este jumper (frente izquierdo de la placa) desconectas AVDD de VIN y puedes inyectar una tensión distinta (3.0 a 5.0 V) para el ADC.
• GND: tierra común.

¿Cuándo conviene separar AVDD? Si tu MCU corre a 3.3 V pero quieres medir potenciómetros conectados a 5 V, cortá el jumper y llevá AVDD a 5 V: te queda rango completo del ADC hasta 5 V manteniendo lógica I2C a 3.3 V. Nada más elegante.

I2C

• SCL / SDA: pines I2C estándar. Ambos tienen pull up de 10 kΩ en la placa (no necesitás externos).
• STEMMA QT (JST SH 4-pin, JST SH 1.0 mm pitch): conector plug and-play compatible con Qwiic de SparkFun. Vale cero soldadura.

Dirección I2C

Por defecto es 0x10. Se puede cambiar de dos formas:

1. Cerrando jumpers de soldar en el reverso (0x11 y 0x17).
2. Conectando resistencias externas al pin ADDR (esquema de la Table 2 del datasheet). Este método permite direcciones intermedias exóticas si ya tienes otros dispositivos en el bus.

Pines A0-A7

Los 8 pines "protagonistas". Cada uno se configura individualmente por software como analog input (SAR 12-bit), digital input, digital push pull output u open drain output.

⚠️ Importante: el ADS7128 NO tiene pull resistors internos. Si vas a usar un pin como entrada digital, tienes que agregar un pull up o pull down externo (10 kΩ típico). Sino leerás basura flotante.

Pin ALRT

Salida open drain que se dispara cuando la lógica interna detecta una condición configurada (cruce de umbral, alerta RMS). Podes engancharlo a un pin de interrupción de tu MCU para no perder eventos por polling lento.

LED de encendido

En la esquina superior izquierda hay un LED verde de "power". Si te molesta consumo o luz en un proyecto de bajo consumo, cortá el jumper del reverso para apagarlo.

Cableado mínimo (potenciómetro en A0)

Este es el circuito de prueba del tutorial. El pot va entre VIN y GND del breakout, con el centro (wiper) al pin A0. Vamos a leer el A0 como analog input y ver cambiar el valor al girar la perilla.

Con STEMMA QT (sin soldar). recomendado si tu MCU tiene el conector:

• MCU 3V (Feather/ESP32/Pico) → VIN del breakout (rojo)
• MCU GND → GND (negro)
• MCU SCL → SCL (amarillo)
• MCU SDA → SDA (azul)

Encima del cable STEMMA:

• Breakout VIN → pot pin positivo
• Breakout A0 → pot wiper (centro)
• Breakout GND → pot pin negativo

Con jumpers Dupont / protoboard:

Idénticas conexiones pero cableadas manualmente. Si tu MCU es 5 V (Arduino Uno) usa 5V → VIN.

Software: CircuitPython (Python en microcontrolador)

Instala la librería adafruit_ads7128 desde el bundle de CircuitPython y copiala a CIRCUITPY/lib/. Necesitas también adafruit_bus_device (dependencia de casi todo el ecosistema Adafruit).

code.py de prueba

# SPDX-FileCopyrightText: 2026 Liz Clark for Adafruit Industries
#
# SPDX-License-Identifier: MIT

"""Simple analog read example for the ADS7128.

Reads a single channel and prints the 16-bit value and the voltage.
"""

import time

import board

from adafruit_ads7128.ads7128 import ADS7128
from adafruit_ads7128.analog_in import AnalogIn

# Reference voltage
REFERENCE_VOLTAGE = 3.3

i2c = board.I2C()
adc = ADS7128(i2c)

# analog input on channel 0
channel = AnalogIn(adc, 0)

while True:
    print(f"value: {channel.value}  voltage: {channel.voltage(REFERENCE_VOLTAGE):.3f} V")
    time.sleep(1.0)

Guardalo como code.py en el drive CIRCUITPY, abre la consola serial (Mu Editor, Thonny o screen /dev/ttyACM0 115200 en Linux), y gira la perilla del pot. Vas a ver el value y el voltage cambiar en vivo.

Detalle importante del wrapper: aunque el hardware es 12-bit (0-4095), la clase AnalogIn retorna un valor normalizado a 16-bit (0-65535) para ser compatible con las otras clases AnalogIn del ecosistema CircuitPython (que están definidas contra el pin ADC del MCU, típicamente 12/16-bit). Esto significa que tu channel.value nunca va a saltar de a 1: siempre va a incrementar en pasos de 16 (65536 / 4096 = 16). No es un bug, es normalizacion.

Uso con Python en Raspberry Pi (linux SBC)

La misma librería funciona desde Python 3 en Raspberry Pi usando Adafruit Blinka (que emula CircuitPython sobre Linux):

sudo pip3 install adafruit-blinka adafruit-circuitpython-ads7128

Habilitá I2C en raspi-config → Interface Options → I2C → Enable. El mismo código Python de arriba corre tal cual en la Pi.

Software: Arduino (C++)

Para Arduino IDE, instala la librería Adafruit_ADS7128 desde Library Manager (Manage Libraries → busca "Adafruit ADS7128"). Acepta instalar todas las dependencias.

Sketch de prueba: leer los 8 canales

/*!
 * @file 01_adc_simpletest.ino
 * @brief Read all 8 ADC channels in manual mode
 *
 * Reads all 8 channels and prints raw values and voltages.
 * Change VREF below to match your supply voltage.
 */

#include <Adafruit_ADS7128.h>

// Set this to your AVDD voltage (3.3 or 5.0)
#define ADS_VREF 3.3

Adafruit_ADS7128 adc;

void setup() {
  Serial.begin(115200);
  while (!Serial) {
    delay(10);
  }

  Serial.println(F("ADS7128 ADC Simple Test"));
  Serial.println(F("======================="));

  // begin() defaults: address ADS7128_DEFAULT_ADDR (0x10), Wire bus &Wire
  if (!adc.begin(ADS7128_DEFAULT_ADDR, &Wire)) {
    Serial.println(F("Failed to find ADS7128!"));
    while (1) {
      delay(100);
    }
  }

  Serial.println(F("ADS7128 initialized!"));
  Serial.println();
}

void loop() {
  Serial.println(F("Channel  Raw    Voltage"));
  Serial.println(F("-------  ----   -------"));

  for (uint8_t ch = 0; ch < 8; ch++) {
    uint16_t raw = adc.analogRead(ch);
    float voltage = adc.analogReadVoltage(ch, ADS_VREF);

    Serial.print(F("   "));
    Serial.print(ch);
    Serial.print(F("     "));
    if (raw < 1000) {
      Serial.print(F(" "));
    }
    if (raw < 100) {
      Serial.print(F(" "));
    }
    if (raw < 10) {
      Serial.print(F(" "));
    }
    Serial.print(raw);
    Serial.print(F("   "));
    Serial.print(voltage, 3);
    Serial.println(F(" V"));
  }

  Serial.println();
  delay(500);
}

Subilo, abre el Serial Monitor a 115200 baud, y vas a ver los 8 canales listados con su lectura raw (0-4095, aquí SÍ es 12-bit "cruda", no normalizada como en CircuitPython) y su voltaje calculado. Gira el pot conectado a A0 y verás el valor cambiar. Los canales A1-A7 sin conexión mostrarán valores random (están flotando).

Ajusta ADS_VREF al voltaje real de tu AVDD:

• Si dejaste el jumper AVDD puenteado a VIN y VIN es 5 V → #define ADS_VREF 5.0
• Si tu MCU es 3.3 V y no separaste AVDD → #define ADS_VREF 3.3
• Si separaste AVDD y le pusiste una referencia distinta → el valor que le pusiste

Errores comunes al debuggear

• "Failed to find ADS7128!": casi siempre es problema de cableado o dirección I2C. Corré un scanner I2C (i2c-scanner.ino en el ejemplos de Wire) para confirmar que el chip aparece en 0x10 (o el address alternativo que hayas configurado). Si no aparece: revisá VCC/GND, SDA/SCL cruzados, y que el pull up externo NO esté en corto.
• Lecturas siempre en 0 o siempre en máximo: pin flotante. Si estás usando un pin como analog input pero no le conectaste nada, va a leer random. Si es digital input sin pull, idem.
• Lecturas ruidosas incluso con pot fijo: agrega un capacitor cerámico de 100 nF entre el wiper del pot y GND para filtrar ruido. Para señales de altimpedancia, algo más grande (1 µF).
• STEMMA QT no cierra bien: los conectores JST SH son diminutos y a veces el cable no queda enganchado por completo. Empújalo hasta oír el click.

Variantes y mejoras

Cinco extensiones que exploran el potencial completo del chip:

• Dashboard visual de los 8 canales con Node RED: el MCU (ESP32 con WiFi) empuja los 8 valores por MQTT cada 250 ms, y Node RED los renderiza como 8 gauges en un dashboard web. Ideal para monitorear un panel de sensores en tiempo real.
• Modo threshold + interrupción real: configura el ADS7128 para disparar ALRT cuando un canal cruza un valor. Conecta ALRT a un pin GPIO con interrupt en el MCU. Ya no polleás I2C: reaccionás en microsegundos a eventos analógicos (detección de golpe, presión superior a X, luz debajo de Y).
• RMS de una señal AC: usa el modo standalone con cómputo de RMS interno para medir el valor eficaz de una corriente sinusoidal (por ejemplo con un shunt + amp op). Perfecto para medidores de consumo AC sin quemar ciclos de CPU.
• Panel de control híbrido: usa 4 pines como analog input (potenciómetros / sliders para volumen o niveles) y los otros 4 como digital output (LEDs de estado). Todo en un solo chip, un solo bus I2C, una sola dirección.
• Multiplexado de sensores: leé 8 sensores analógicos distintos (LDR, termistores NTC, celdas de carga con amp) con un solo chip. Con muestreo secuencial de los 8 canales a 100 Hz cada uno, tienes buena cobertura para telemetría de sistemas lentos.

Personalización para Chile

El ADS7128 es un producto de nicho relativamente nuevo, así que no siempre está en stock localmente. Alternativas honestas:

• ADS1115 (Adafruit o clon genérico): 4 canales ADC 16-bit por I2C. Es el estándar de facto en Chile y disponible en casi cualquier tienda de electrónica. Trade off: solo 4 canales (vs 8), y no tiene la parte de GPIO expander ni el hardware RMS del ADS7128. Si tu proyecto solo necesita ADC extra de alta resolución, ADS1115 es más práctico. NO es un reemplazo directo del ADS7128 (falta el GPIO), pero es lo más cercano a nivel ADC.
• PCF8574 + ADS1115 en paralelo: si quieres replicar el combo ADC+GPIO con partes disponibles localmente, usa un ADS1115 (4 ADC 16-bit) más un PCF8574 (8 GPIO I2C). Dos chips, dos direcciones, más ruteo. pero total ~US$5 en piezas comunes.
• Adafruit Feather RP2040 / ESP32 V2 Feather: MCUs con STEMMA QT integrado para plug and-play. Como alternativa disponible en tiendas locales: ESP32 DevKit V1, Raspberry Pi Pico con headers a soldar. En ambos casos puedes cablear con jumpers Dupont.
• Potenciómetro 10 kΩ: componente básico, disponible en cualquier tienda de electrónica local. Elige lineal (marca B10K) para respuesta proporcional; los logarítmicos (A10K) sirven mejor para audio.
• Cable STEMMA QT / Qwiic (JST SH 4-pin): si no lo consigues local, usa jumpers Dupont soldados al header expuesto. Es más feo pero funciona igual.
• Protoboard 830 puntos y jumpers macho macho: estándar en cualquier tienda de electrónica.

Estimación de costo total del proyecto en Chile (versión ADS7128 con placa importada + MCU local): ~CLP $35.000 - $55.000. Versión con ADS1115 + PCF8574 (equivalente funcional sin RMS ni ALRT): ~CLP $18.000 - $25.000.

Recursos

• Tutorial original: Adafruit ADS7128 8-Channel ADC and GPIO Expander por Liz Clark. Adafruit Learning System
• Librería CircuitPython: github.com/adafruit/Adafruit_CircuitPython_ADS7128
• Librería Arduino: github.com/adafruit/Adafruit_ADS7128
• Datasheet ADS7128 (Texas Instruments): ti.com/product/ADS7128
• Adafruit Blinka (CircuitPython en Linux): github.com/adafruit/Adafruit_Blinka
• Archivos EagleCAD del PCB: en el repositorio Adafruit del producto (Fritzing library incluida)

Versión chilena con comparación explícita contra ADS1115 + PCF8574 (alternativas disponibles en stock local) y consideraciones prácticas para debuggear I2C en microcontroladores 3.3 V vs 5 V.