rbAmp
ES
Tienda
Docs
Actualizado · Editar en GitHub [Edit on GitHub]

04 · Cableado

Este capítulo trata de la conexión física del módulo rbAmp a un host Python: la disposición de pines del lado de baja tensión, los requisitos de alimentación, la compatibilidad de niveles I²C, la longitud del bus y los pines por defecto de cada tipo de host. Los hosts admitidos son CPython en SBC Linux y x86 + USB-I²C, y MicroPython en ESP32 / RP2040 / STM32 / Pyboard.

El usuario trabaja solo con el lado de baja tensión (alimentación + I²C + DRDY opcional); todo lo que toca la red queda dentro de la carcasa.

Seguridad

⚠ Seguridad eléctrica. La tensión de red puede matar. Desconecte y bloquee el circuito antes de conectar los terminales L/N o colocar la pinza; que un técnico cualificado haga el cableado de red y cualquier trabajo dentro de un cuadro. Coloque la pinza solo sobre un conductor (L): nunca sobre todo el cable (si abraza L y N, lee ~0). La pinza en sí no tiene contacto eléctrico.

Cable y fusible (conexión de tensión). AWG26–22 es suficiente, ya que el sensor de tensión consume muy poca corriente. Un fusible en la línea L es obligatorio, de hasta 0.1 A.

Pinout del lado de baja tensión

Cabecera de baja tensión del módulo: VCC, GND, SDA, SCL y el pin DRDY opcional, con lo que necesita cada uno.

El módulo funciona con lógica I²C de 3.3 V y tolera 5 V en las líneas de señal. Todos los pines de baja tensión están totalmente aislados galvánicamente de la red.

Pin Señal Finalidad
VCC +5 V (4.5..5.5 V) Alimentación del módulo; mínimo 4.5 V para un funcionamiento correcto
GND Tierra Común con el host: obligatorio
SDA SDA I²C Datos I²C
SCL SCL de I²C Reloj I²C
DRDY Datos listos (opcional) Drenador abierto, pulso BAJO de ~10 µs cada ~100 ms

Potencia

Parámetros de VCC

  • Tensión nominal: 5 V CC
  • Rango permitido: 4.5..5.5 V
  • Corriente de alimentación: ~15 mA típica, ~25 mA de pico al escribir en flash
  • Rizado: < 50 mV pico a pico (para la precisión de medida)

El módulo incorpora un regulador a bordo, un filtro RC, condensadores cerámicos y una perla de ferrita: no hace falta ningún filtrado adicional por parte del usuario. Puede alimentar el módulo desde el raíl +5V o 5V0 de cualquier host (pin 2/4 de la Raspberry Pi, USB-5V de un ESP32 DevKitC, V+ de un Pyboard, etc.).

Compatibilidad de niveles I²C

  • SDA / SCL trabajan con lógica de 3.3 V (las pull-ups integradas llevan las líneas a 3.3 V).

  • Las líneas toleran 5 V, pero todos los hosts mencionados abajo (Raspberry Pi / familia ESP32 / RP2040 / STM32 / Pyboard) ya trabajan con lógica de 3.3 V: no se necesitan convertidores de nivel.

  • El adaptador USB-I²C pyftdi (FT232H / MCP2221) también tiene lógica de 3.3 V: conexión directa.

Comportamiento al encendido

  • Arranque en frío: ~250 ms hasta el primer resultado válido.
  • Tras un reinicio (por software o por caída de tensión): ~250 ms para recuperarse.
  • Hasta el primer resultado válido, los registros se leen como 0 y el indicador DATA_VALID = 0.

El paquete espera a que el módulo esté listo dentro de dev.begin(): el código de usuario simplemente llama a begin() (o usa el gestor de contexto with RbAmp(bus, 0x50) as dev:, que llama a begin() automáticamente en __enter__).

Aislamiento

El módulo en sí es completamente de baja tensión: no tiene ningún circuito de medida de alta tensión. La corriente se lee con una pinza CT que se acopla magnéticamente desde fuera del conductor aislado, sin contacto eléctrico con el cable de red. En las variantes con medida de tensión (UI), la única referencia de red es el borne L–N, que alimenta un divisor de detección aislado galvánicamente*; las variantes solo de amperios no tienen conexión a la red. Consecuencias:

  • El GND del módulo no está conectado a la línea de red ni al neutro.
  • Conectar el lado de baja tensión al host Python es seguro: no hay riesgo de cortocircuito a través de tierra.
Seguridad

⚠ No abra la carcasa del módulo: hacerlo anula la calibración de fábrica.

Resistencias pull-up integradas — en la placa

Importante: cada módulo rbAmp trae resistencias pull-up integradas de 4.7 kΩ en SDA y SCL a 3.3 V. Para un único módulo en el bus no se necesitan pull-ups externas: conecte el host directamente.

Cuándo desactivar las pull-ups integradas

Si hay varios módulos rbAmp en el bus (u otros dispositivos I²C con sus propias pull-ups), conectarlos en paralelo da una resistencia efectiva demasiado baja, lo que:

  • Aumenta el consumo de corriente del bus
  • Puede superar la corriente de sumidero máxima de la etapa de salida del maestro I²C
  • Añade capacitancia en un bus largo sin mejorar apenas la inmunidad al ruido

Solución: en la cara inferior de la placa de cada módulo, junto a las resistencias pull-up, hay puentes de soldadura (serigrafía Pull-Up). Córtelos con una cuchilla afilada:

  • Deje las pull-ups activadas en un solo módulo (o muévalas a un único punto cerca del host).

  • Corte los puentes de soldadura de los demás módulos.

Regla general

Dónde se dejan las resistencias de pull-up de I²C para uno a tres módulos en un bus corto y para cuatro o más, y cómo se cortan los puentes de soldadura.

Módulos rbAmp en el bus Pull-ups
1 Déjelo como está (las 4.7 kΩ integradas funcionan)
2 Conservar en uno, cortar en el otro
3 Corte en todos los módulos, monte un par externo de 2.7…3.3 kΩ cerca del host
4…6 Corte en todos los módulos, un par externo de 2.2…2.7 kΩ cerca del host
7…16 Corte en todos los módulos, un par externo de 1.5…2.2 kΩ cerca del host; compruebe la capacitancia del bus (≤ 400 pF) y reduzca la velocidad del bus si hace falta

Los valores externos son valores recomendados (calculados a partir de la especificación I²C: corriente de sumidero ≤ 3 mA a 3.3 V, capacidad del bus ≤ 400 pF). Conecte las resistencias de pull-up externas a 3.3 V (el nivel lógico del bus), no a la alimentación de 5 V VCC.

En caso de duda

: mida la resistencia entre SDA y VCC con los dispositivos apagados. Debe estar en el rango de 1.5..4.7 kΩ. Si es menor, hay demasiadas pull-ups activas en paralelo.

Parámetros del bus I²C

  • Dirección por defecto: 0x50 (7 bits)
  • Rango de direcciones: 0x08..0x77 (reasignable en fábrica)
  • Velocidad recomendada en MicroPython + ESP32: 50 kHz; mitiga el patrón de NACK de base con el firmware v1 (véase la sección siguiente).

  • Velocidad recomendada en CPython + SBC Linux: 100 kHz (el patrón de NACK no aparece con el driver I²C del kernel: la ruta smbus2 de Linux no tiene el problema de reintentos descrito para ESP-IDF).

  • Acceso a varios bytes: las lecturas pueden hacerse en ráfaga (varios bytes en una transacción); las escrituras van byte a byte, cada una con una dirección de registro explícita. El paquete lo hace correctamente por sí mismo; el código del usuario nunca lo ve.

Longitud del bus

El I²C es un bus corto (~15 cm por defecto). Muchos usuarios conectan los módulos con cables de puente de baja calidad, que captan mucho ruido y pierden numerosas transferencias; de ahí el límite corto. Topologías recomendadas para rbAmp:

Cable Longitud máxima Velocidad
JST estándar / 4 conductores planos hasta 0.15 m 100 kHz
Par trenzado UTP (cat-5/5e/6): SDA+GND y SCL+GND en pares separados hasta 1 m 100 kHz
Par trenzado + buffer I²C (PCA9515 / TCA9617) hasta 3 m 100 kHz
Bus diferencial (PCA9615 / LTC4332) hasta 100 m 100 kHz
Seguridad

Para longitudes superiores a 0.15 m, el par trenzado es obligatorio: SDA y SCL deben ir en pares distintos, cada uno con su propia masa. SDA y SCL en el mismo par crean una capacidad de acoplamiento cruzado que distorsiona los flancos.

⚠ Dentro de un armario eléctrico, apantalle el cable I2C. Los campos magnéticos intensos cerca de conductores de red, contactores y transformadores inducen ruido en un cable sin apantallar. Mantenga el cable lo más corto posible y alejado del cableado de red.

Bus multimódulo: la topología principal

El caso de uso canónico de la biblioteca es varios módulos rbAmp en un único bus I²C, gestionados por un ESP32 / Raspberry Pi / SBC a través de RbAmpFleet. Todas las reglas y optimizaciones siguientes están diseñadas precisamente para esta topología; un módulo único es un caso particular (el mismo manejador, pero las llamadas de flota se reducen a triviales).

Varios módulos en un bus I²C con sus pull-ups integradas cortadas y un par externo en el maestro, además de las tres opciones de DRDY.

Despliegues típicos

Escenario Configuración Número de módulos
Canon del 80 %: entrada de servicio de la vivienda + submedidores 1× UI1 (entrada, energía de red) + 3-6× UI1/I1 (cargas) 4-7
Subpanel con desglose de corriente 1× UI1 (entrada) + 1-2× I2/I3 (corriente por circuito) 3-5
Submedición industrial 1× UI1 (entrada) + N× I2/I3 (por máquina, desglose de corriente) hasta ~16

Límites eléctricos

  • Número de módulos: hasta ~16 (capacidad total del bus ≤ 400 pF a 100 kHz; a 50 kHz el margen es mayor).
  • Pull-ups del bus de la flota (importante): cada módulo trae 4.7 kΩ integradas. En un bus multimódulo, N pull-ups trabajan en paralelo → el sumidero se sobrecarga y el bus no puede bajar a LOW. A partir de 4 módulos (o antes en un bus de más de 15 cm) corte las pull-ups integradas en todos los módulos menos uno; con 2–3 módulos en un bus de hasta 15 cm, déjelas como están (ese caso está medido), o córtelas en todos y deje solo un par externo (2.7…3.3 kΩ para 3 módulos, menos para buses mayores; véase la tabla anterior) a 3.3 V en un único punto del bus, recomendado para tramos largos, con ruido o con ESP32 como maestro).
  • Las pull-ups internas del ESP32 (~45 kΩ) son demasiado débiles para un bus multimódulo con una longitud de pista real: hacen falta pull-ups externas (valores: véase la tabla de arriba). Es parte de la mitigación en tres capas contra el bloqueo de un bus marginal; véase 10 · Solución de problemas, sección "El script se cuelga / falla por timeout".

Direccionamiento: aprovisionamiento y cambio en campo (apto para producción)

Aprovisionamiento de módulos de uno en uno: solo un módulo que siga en la dirección por defecto está en el bus mientras se le asigna su dirección de trabajo.

La dirección de fábrica por defecto es 0x50. Cada módulo nuevo o de reposición pasa por aprovisionamiento (una vez): cambio de dirección desde 0x50 a una dirección de trabajo, más guardado opcional de la configuración (modelos de CT, group_id, etiqueta) en flash. El modo de fábrica no es necesario: el cambio de dirección funciona directamente en producción mediante un commit en dos fases.

Método 1: bajo nivel prepare_address_change / commit_address_change (API actual):

Python
dev.prepare_address_change(0x52)   # arms candidate, 5 s window
dev.commit_address_change()        # magic 0xA5 + CMD_COMMIT_ADDR + reset
time.sleep(0.3)                     # boot window
# dev.address is now == 0x52

Método 2: el envoltorio RbAmpFleet (recomendado para despliegues de flota):

Python
from rbamp import RbAmpFleet

fleet = RbAmpFleet(bus)
fleet.scan()
fleet.assign_address(dev, 0x52)   # two-phase + reset + handle rebind

El protocolo de bajo nivel (como referencia):

Text
1. write candidate_addr → REG_I2C_ADDRESS (0x30, in RAM)
2. write 0xA5 → REG_ADDR_COMMIT_MAGIC (0x31, armed; 5-second window)
3. issue CMD_COMMIT_ADDR (opcode 0x30 in REG_COMMAND)
4. wait ~700 ms (flash erase + write)
5. issue CMD_RESET (opcode 0x01) — CMD_COMMIT_ADDR does not auto-reset
6. wait ~300 ms; the module responds at the new address
Seguridad

✅ Lectura de la dirección: REG_I2C_ADDRESS (0x30) al arrancar lee la dirección activa. Tras el reinicio posterior a la confirmación, leer 0x30 muestra la nueva activa. Durante la preparación refleja la candidata hasta la confirmación. La biblioteca garantiza que el estado de armado se borra mediante try/finally si falla a medias — RbAmpTimeoutError si la ventana expiró.

⚠ Disciplina de aprovisionamiento: DEBE haber un único módulo virgen cada vez.

La causa más habitual de fallo en el aprovisionamiento es tener más de un módulo con la dirección de fábrica 0x50 en el bus. Distinguirlos por I²C es físicamente imposible (conexión open-drain en AND cableada: ambos módulos responden ACK de forma idéntica, y la lectura de datos saldrá "mezclada").

Por eso la regla es estricta (un MUST normativo, no una recomendación): en el momento en que se llama a prepare_address_change(), debe haber exactamente un módulo en 0x50 en el bus (uno nuevo, o uno devuelto a valores de fábrica mediante una herramienta de banco aparte).

Ruta de recuperación si sospecha una violación de la disciplina: 1. Corte la alimentación de todos los módulos. 2. Desconecte físicamente todos menos uno «virgen». 3. Llame a prepare_address_change() en el bus con un único módulo. 4. Añada los demás de uno en uno, aprovisionando cada uno por separado.

Presupuesto de energía del bus

A 50 kHz, una transacción de lectura ≈ 200-400 µs. Un bloque RT completo para un canal (U + I + P + PF) ≈ 5-8 ms por canal.

Configuración Bus por ciclo A 50 kHz Frecuencia máxima de sondeo
1× UI1, bloque RT ~5 ms < 5 ms 100+ Hz (pero el módulo actualiza a 10 Hz)
5× UI1, bloque RT ~25 ms ~25 ms hasta 10 Hz
16× I3, RT + período ~400 ms 400 ms > 100 ms no puede seguir el ritmo del módulo (10 Hz); como mucho ~2 Hz
Nota

Las cifras son estimaciones.

Regla: a 50 kHz los límites cómodos son 8-10× I3 o 15-16× UI1 con sondeo a 5 Hz (cada segunda ventana de módulo), y aproximadamente la mitad a 10 Hz completos.

Sincronización de periodos — alinear los periodos

Para la medición tarifaria, todos los módulos deben tomar la instantánea del mismo intervalo.

Un único comando de difusión hace que todos los módulos tomen su instantánea de periodo en el mismo instante.

Estrategia 1: instantánea secuencial + estabilización común (cualquier firmware):

Python
import time

# Phase 1: sequential snapshot
for m in meters:
    m.latch_period()

# Phase 2: common settle (≥ 50 ms)
time.sleep(0.050)

# Phase 3: read the snapshots with skip_latch=True
snaps = [m.read_period_snapshot(skip_latch=True) for m in meters]

Desfase: 16 módulos × ~1 ms/instantánea = ~16 ms respecto a un periodo de 60 s = 0.027 %. Despreciable para la monitorización habitual.

Estrategia 2 — instantánea por difusión General-Call (requiere activarla en cada módulo):

Todos los módulos toman su instantánea en una única trama I²C a la dirección 0x00:

Text
addr=0x00 | A5 27      (5 bytes)

Desfase = 0 (atómico). Preconfiguración (una vez en cada módulo de la flota):

  1. dev.write_reg(0x27, 0x01) (activa el indicador GC_ENABLE de FLEET_CONFIG)
  2. dev.save_user_config()
  3. dev.reset() (asentamiento ~300 ms)

Testigo: para cada esclavo esperado, lea REG_PERIOD_VALID (0x07). !=1 → recurra a la estrategia 1.

Seguridad

⚠ Activación opcional de GC (C.10): si GC está desactivado en toda la flota, la dirección GC responde con NACK. El maestro recibe un error duro (no una pérdida silenciosa): esto es detectable, no un fallo.

Filtrado por grupo GC (bus multiusuario)

REG_GROUP_ID (0x28) permite tener varios dominios GC en un mismo bus:

  • group = 0x00 → llamada general (all-call).
  • group = N → solo los módulos con REG_GROUP_ID = N toman la instantánea.

Caso de uso: separar grupos tarifarios.

Modos de fallo

Síntoma Causa Qué hacer
i2c bus scan muestra varios módulos en la misma dirección tras añadir uno en campo Un módulo nuevo en 0x50 entra en conflicto Reasígnele la dirección por separado antes de añadirlo
Un módulo responde NACK con más frecuencia que los demás Fallo de cable / caída de VCC Compruebe VCC bajo carga
Tras una trama GC, un módulo no toma la instantánea GC_ENABLE de FLEET_CONFIG está desactivado o el grupo no coincide Compruebe REG_FLEET_CONFIG y REG_GROUP_ID

Los escenarios detallados con varios módulos están en 06 · Ejemplos.

Hosts CPython (SBC Linux + x86)

Raspberry Pi (cualquier modelo)

El bus I²C 1 va al conector de 40 pines. En la mayoría de modelos (1B+ / 2 / 3 / 4 / 5) los pines son los mismos:

rbAmp Cabecera de 40 pines de la RPi GPIO (BCM)
VCC pin 2 (+5V) —
GND pin 6 (o cualquier GND) —
SDA pin 3 GPIO 2 (SDA1)
SCL pin 5 GPIO 3 (SCL1)
DRDY (optional) cualquier GPIO libre con soporte de interrupción

Active el driver I²C del kernel: sudo raspi-config → 3 Interface Options → I2C → Yes. O edite manualmente /boot/firmware/config.txt (/boot/config.txt en versiones antiguas de Raspberry Pi OS):

Text
dtparam=i2c_arm=on
dtparam=i2c_arm_baudrate=100000   # 100 kHz (default 100 kHz)

Instale la herramienta de escaneo y permita a su usuario abrir el bus (cierre y vuelva a abrir la sesión después), y compruebe que el módulo responde:

Shell
sudo apt install i2c-tools
sudo usermod -aG i2c $USER
i2cdetect -y 1        # should show 0x50

Uso desde Python:

Python
from smbus2 import SMBus
from rbamp import RbAmp

with SMBus(1) as bus:
    with RbAmp(bus, 0x50) as dev:
        print(dev.voltage, "V")

Instalación de smbus2: pip install smbus2 (o el paquete del sistema sudo apt install python3-smbus).

Orange Pi 5 / Rock Pi 5 / otros SBC Linux

El mismo smbus2.SMBus(N), donde N es el número de bus de /dev/i2c-N. Normalmente /dev/i2c-1 o /dev/i2c-0. Compruebe:

Shell
ls /dev/i2c-*
i2cdetect -y 1     # should show 0x50

La asignación de pines depende de la placa concreta: consulte su hoja de datos.

x86 / Windows / macOS — mediante un adaptador USB-I²C

Los hosts x86 no tienen I²C nativo. La solución es un adaptador USB-I²C (FT232H, MCP2221, Bus Pirate v4, CH341). pyftdi.i2c.I2cController por sí solo no tiene ni la firma compatible con smbus2 (read_byte_data / write_byte_data) ni la firma de MicroPython (readfrom_mem / writeto_mem): no puede pasarse directamente a RbAmp(...); la autodetección del bus lanzará RbAmpParamError.

Los adaptadores x86 requieren una clase envoltorio fina que implemente la interfaz de backend de tipado por duck typing (read_byte / write_byte / register_acks / now_ms; véase 09 · Referencia de la API, sección «Autodetección del bus»). Para otros adaptadores, escriba su propio envoltorio tomando como modelo _io_smbus.py / _io_micropython.py.

Hosts MicroPython

ESP32 / ESP32-S2 / ESP32-S3 / ESP32-C3

Python
from machine import I2C, Pin
from rbamp import RbAmp

# ESP32 DevKitC default I²C pinning
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=50_000)   # 50 kHz recommended on ESP32
with RbAmp(i2c, 0x50) as dev:
    print(dev.voltage, "V")
Chip SDA / SCL por defecto (recomendado) Puerto I²C
ESP32 (original / WROOM / DevKitC) GPIO 21 / GPIO 22 I2C(0, ...)
ESP32-S2 GPIO 21 / GPIO 22 (misma convención) I2C(0, ...)
ESP32-S3 GPIO 8 / GPIO 9 (por defecto para la placa N16R8) I2C(0, ...)
ESP32-C3 GPIO 5 / GPIO 6 I2C(0, ...)

Para otros chips, compruebe el firmware MicroPython de su ESP32 (mpremote eval 'help(machine.I2C)').

Raspberry Pi Pico / Pico W (RP2040)

Python
from machine import I2C, Pin
from rbamp import RbAmp

# Pico — two hardware I²C blocks (I2C0 and I2C1)
i2c = I2C(0, scl=Pin(1), sda=Pin(0), freq=100_000)   # 100 kHz OK on RP2040
with RbAmp(i2c, 0x50) as dev:
    print(dev.voltage, "V")

La Pico no sufre el patrón de NACK de base: MachineI2CBackend detecta RP2040 automáticamente y reduce el reintento por defecto a 1 intento.

STM32 / Pyboard / Nucleo (mediante MicroPython)

Python
from machine import I2C
from rbamp import RbAmp

# Pyboard — soft-I²C or hardware I²C block
i2c = I2C(1, freq=100_000)   # bus 1 — X9/X10 on the Pyboard
with RbAmp(i2c, 0x50) as dev:
    print(dev.voltage, "V")

STM32 no sufre el patrón base de NACK: MachineI2CBackend reduce el valor por defecto de reintentos a 1 en estas placas.

Patrón base de NACK de MicroPython en ESP32: 50 kHz

Al ejecutar MicroPython en ESP32, el firmware rbAmp actual presenta NACK frecuentes a 100 kHz, bastante menos a 50 kHz. Esto es específico de la pila I²C de ESP-IDF sobre la que se apoya MicroPython en ESP32. En los demás puertos de MicroPython (RP2040 / STM32 / Pyboard) el problema no aparece.

El paquete aborda esto en dos capas:

  1. Velocidad por defecto de 50 kHz: se recomienda pasar freq=50_000 a machine.I2C(...) en ESP32.

  2. Reintento por byte en MachineI2CBackend: 3 intentos × hueco de 5 ms por defecto. Configurable a través de la API avanzada:

Python
from rbamp._io_micropython import MachineI2CBackend
from rbamp import RbAmp

backend = MachineI2CBackend(i2c, retry_attempts=5, retry_gap_ms=5)
dev = RbAmp(backend, 0x50)   # the address is a parameter of RbAmp, not of the backend

Para más sobre el diagnóstico de problemas a nivel de bus, véase 10 · Solución de problemas. Los contadores MachineI2CBackend.retry_exhaustion_count y RbAmp.sanity_reject_count están disponibles para la observabilidad en pruebas de resistencia prolongadas.

DATA_READY (DRDY)

Un pin opcional para optimizar el sondeo. Si la aplicación consulta el módulo como máximo una vez cada 100 ms, DRDY puede dejarse sin conectar.

Parámetros eléctricos

  • Tipo de salida: drenador abierto (sin pull-up activa a VCC)
  • Nivel en reposo: ALTO (requiere una pull-up en el host: la pull-up integrada del GPIO o una resistencia externa; se recomienda 10 kΩ a 3.3 V)

  • Pulso de listo: BAJO durante ~10 µs después de que los registros RT se hayan actualizado con datos nuevos

  • Frecuencia de pulso: ~10 Hz (un pulso por ventana RT de ~100 ms)

Semántica

Un flanco de bajada en DRDY garantiza que todos los registros RT están sincronizados y publicados (el firmware los actualiza de forma atómica en la ISR antes de bajar el pin). Tras el flanco de bajada, el maestro puede leer el bloque RT sin riesgo de obtener una muestra partida.

Patrón de interrupción en MicroPython

Python
from machine import Pin
import uasyncio as asyncio
from rbamp import RbAmp

DRDY_PIN = 15
drdy_event = asyncio.Event()

def drdy_irq(pin):
    drdy_event.set()   # ISR-safe — Event.set() is atomic on uPy

async def bidir_task(dev):
    while True:
        await drdy_event.wait()
        drdy_event.clear()
        try:
            p = dev.read_power(0)
            # ...integrate + publish...
        except Exception as e:
            print("read failed:", e)

# In main:
drdy = Pin(DRDY_PIN, Pin.IN, Pin.PULL_UP)
drdy.irq(trigger=Pin.IRQ_FALLING, handler=drdy_irq)
asyncio.run(bidir_task(dev))

Patrón en CPython (SBC Linux)

En la Raspberry Pi mediante gpiozero o RPi.GPIO:

Python
from gpiozero import Button
from threading import Event
from rbamp import RbAmp

drdy_event = Event()
drdy = Button(15, pull_up=True, bounce_time=None)   # GPIO 15 as an example
drdy.when_pressed = lambda: drdy_event.set()       # falling edge

while True:
    drdy_event.wait()
    drdy_event.clear()
    try:
        p = dev.read_power(0)
        # ...integrate + publish...
    except Exception as e:
        print("read failed:", e)

DRDY es opcional: sondear a cualquier tasa ≤ 10 Hz funciona también sin él. El paquete no depende de DRDY en ninguna de sus rutas.

Módulos STANDARD (STD)

Los módulos STD usan el mismo cableado I²C, las mismas consideraciones de pull-up, la misma dirección (por defecto 0x50) y los mismos parámetros de bus que se describen en este capítulo, y el mismo constructor RbAmp(bus, addr). La biblioteca detecta la línea de módulo en begin(); no hace falta cableado ni configuración adicional.

  • Las llamadas exclusivas de STD (energía en el propio dispositivo, ángulos de tensión, corriente de arranque, ...) lanzan RbAmpNotSupportedError en un módulo BASIC.

  • Algunas funciones STD necesitan una imagen de módulo suficientemente reciente; con una imagen antigua la llamada lanza RbAmpNotSupportedError («no disponible»).

  • Las funciones de energía, ángulo y corriente de arranque en el propio dispositivo están validadas en CPython (smbus2). La ruta de 16 bits de MicroPython está implementada, pero aún no está validada en hardware: para estas funciones prefiera un host CPython (Raspberry Pi y otras SBC Linux, arriba) hasta que una nota de versión diga lo contrario.

Véase 09 · Referencia de la API.


Fuente y incidencias: rb-amp/rbamp-python · esta página en el repositorio: docs/04_hardware.md (v1.6.1)