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 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
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/SCLtrabajan 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
0y el indicadorDATA_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
GNDdel 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.
⚠ 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
| 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.
: 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 |
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).
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)
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):
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):
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):
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
✅ 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 |
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
Multimódulo — instantánea simultánea (medición por periodo) · 6.4 Sincronización de periodo — dos estrategias (referencia de la API)
Para la medición tarifaria, todos los módulos deben tomar la instantánea del mismo intervalo.
Estrategia 1: instantánea secuencial + estabilización común (cualquier firmware):
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:
addr=0x00 | A5 27 (5 bytes)
Desfase = 0 (atómico). Preconfiguración (una vez en cada módulo de la flota):
dev.write_reg(0x27, 0x01)(activa el indicadorGC_ENABLEde FLEET_CONFIG)dev.save_user_config()dev.reset()(asentamiento ~300 ms)
Testigo: para cada esclavo esperado, lea REG_PERIOD_VALID (0x07). !=1 → recurra a la estrategia 1.
⚠ 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 conREG_GROUP_ID = Ntoman 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):
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:
sudo apt install i2c-tools
sudo usermod -aG i2c $USER
i2cdetect -y 1 # should show 0x50
Uso desde 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:
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
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)
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)
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:
-
Velocidad por defecto de 50 kHz: se recomienda pasar
freq=50_000amachine.I2C(...)en ESP32. -
Reintento por byte en
MachineI2CBackend: 3 intentos × hueco de 5 ms por defecto. Configurable a través de la API avanzada:
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
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:
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
RbAmpNotSupportedErroren 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.
Enlaces
-
05 · Inicio rápido — el primer script funcional para ambos backends
-
06 · Ejemplos — escenarios de trabajo (incluidos el bus multimódulo y el streaming asíncrono)
-
09 · Referencia de la API: detalles del backend y accesores de los contadores de reintentos y validación
-
10 · Solución de problemas — depuración a nivel de bus, patrón de NACK, disciplina de reintentos y filtro de validez
Fuente y incidencias: rb-amp/rbamp-python · esta página en el repositorio: docs/04_hardware.md (v1.6.1)