04 · Cablagem
Este capítulo trata da ligação física do módulo rbAmp a um host Python: a pinagem do lado de baixa tensão, os requisitos de alimentação, a compatibilidade de níveis I²C, o comprimento do barramento e os pinos padrão de cada tipo de host. Os hosts suportados são CPython em SBC Linux e x86 + USB-I²C, e MicroPython em ESP32 / RP2040 / STM32 / Pyboard.
O utilizador trabalha apenas com o lado de baixa tensão (alimentação + I²C + DRDY opcional); tudo o que toca na rede fica dentro da caixa.
⚠ Segurança elétrica. A tensão da rede pode matar. Desligue e bloqueie o circuito antes de ligar os terminais L/N ou de colocar a pinça; deixe o trabalho de ligação à rede e qualquer trabalho dentro de um quadro a cargo de uma pessoa qualificada. Coloque a pinça em um condutor apenas (L) — nunca no cabo inteiro (com L e N na pinça lê ~0). A própria pinça é sem contacto.
Fio e fusível (ligação de tensão). AWG26–22 é suficiente — o sensor de tensão consome muito pouca corrente. Um fusível na linha L é obrigatório, com calibre até 0.1 A.
Pinout do lado LV
O módulo funciona com lógica I²C de 3.3 V e é tolerante a 5 V nas linhas de sinal. Todos os pinos LV estão totalmente isolados galvanicamente da rede.
| Pino | Sinal | Finalidade |
|---|---|---|
VCC |
+5 V (4.5..5.5 V) | Alimentação do módulo; mínimo de 4.5 V para funcionamento correto |
GND |
Terra | Comum com o anfitrião — obrigatório |
SDA |
SDA I²C | Dados I²C |
SCL |
I²C SCL | Relógio I²C |
DRDY |
Data-ready (opcional) | Dreno aberto, impulso LOW de ~10 µs a cada ~100 ms |
Potência
Parâmetros de VCC
- Tensão nominal: 5 V DC
- Gama permitida: 4.5..5.5 V
- Corrente de alimentação: ~15 mA típico, ~25 mA de pico ao escrever na flash
- Ripple: < 50 mV pico a pico (para a precisão da medição)
O módulo tem um regulador incorporado, um filtro RC, condensadores cerâmicos e uma conta de ferrite — não é necessária filtragem adicional por parte do utilizador. Pode alimentar o módulo a partir do trilho +5V ou 5V0 de qualquer host (pino 2/4 do Raspberry Pi, USB-5V de ESP32 DevKitC, V+ do Pyboard, etc.).
Compatibilidade de níveis I²C
-
SDA/SCLfuncionam com lógica de 3.3 V (os pull-ups incorporados puxam as linhas para 3.3 V). -
As linhas são tolerantes a 5 V, mas todos os hosts mencionados abaixo (Raspberry Pi / família ESP32 / RP2040 / STM32 / Pyboard) já trabalham com lógica de 3.3 V — não são necessários conversores de nível.
-
O dongle USB-I²C
pyftdi(FT232H / MCP2221) também tem lógica de 3.3 V — ligação direta.
Comportamento no arranque
- Arranque a frio: ~250 ms até ao primeiro resultado válido.
- Após uma reposição (por software ou por quebra de tensão): ~250 ms para recuperar.
- Até ao primeiro resultado válido, os registos lêem
0e a flagDATA_VALID= 0.
O pacote espera que o módulo fique pronto dentro de dev.begin() — o código do utilizador limita-se a chamar begin() (ou usa o context manager with RbAmp(bus, 0x50) as dev:, que chama begin() automaticamente em __enter__).
Isolamento
O próprio módulo é inteiramente de baixa tensão — não tem nele qualquer circuito de medição de alta tensão. A corrente é lida por uma pinça TC que acopla magneticamente a partir do exterior do condutor isolado, sem contacto elétrico com o fio da rede. Nas variantes de deteção de tensão (UI) a referência única da rede é o terminal L–N, que alimenta um divisor de deteção isolado galvanicamente*; as variantes apenas de amperes não têm qualquer ligação à rede. Consequências:
- O
GNDdo módulo não está ligado à fase nem ao neutro da rede. - Ligar o lado de baixa tensão ao host Python é seguro — não há risco de curto-circuito através da terra.
⚠ Não abra a caixa do módulo — fazê-lo anula a calibração de fábrica.
Resistências pull-up incorporadas — na placa
Importante: todo o módulo rbAmp vem com resistências de pull-up de 4.7 kΩ integradas em SDA e SCL para 3.3 V. Para um único módulo no barramento não são necessários pull-ups externos — ligue o anfitrião diretamente.
Quando desativar os pull-ups integrados
Se houver vários módulos rbAmp no barramento (ou outros dispositivos I²C com os seus próprios pull-ups), ligá-los em paralelo produz uma resistência efetiva demasiado baixa, o que:
- Aumenta a corrente consumida no barramento
- Pode exceder a corrente máxima de sumidouro do estágio de saída do mestre I²C
- Acrescenta carga capacitiva num barramento longo, pouco contribuindo para a imunidade ao ruído
Solução: na face inferior da placa de cada módulo, junto às resistências de pull-up, existem jumpers de solda (serigrafia Pull-Up). Corte-os com uma lâmina afiada:
-
Mantenha os pull-ups ativos em apenas um módulo (ou mova-os para um ponto único perto do host).
-
Corte as pontes de solda nos restantes módulos.
Regra prática
| Módulos rbAmp no barramento | Pull-ups |
|---|---|
| 1 | Deixe como está (os 4.7 kΩ incorporados funcionam) |
| 2 | Manter num, cortar no outro |
| 3 | Corte em todos os módulos, instale um par externo de 2.7…3.3 kΩ perto do host |
| 4…6 | Corte em todos os módulos, instale um par externo de 2.2…2.7 kΩ perto do host |
| 7…16 | Corte em todos os módulos, um par externo de 1.5…2.2 kΩ perto do anfitrião; verifique a capacidade do barramento (≤ 400 pF), baixe a velocidade do barramento se necessário |
Os valores externos são valores recomendados (calculados a partir da especificação I²C: corrente de sumidouro ≤ 3 mA a 3.3 V, capacidade do barramento ≤ 400 pF). Ligue os pull-ups externos a 3.3 V (o nível lógico do barramento), e não à alimentação VCC de 5 V.
: meça a resistência entre SDA e VCC com os dispositivos desligados. Deve estar na faixa 1.5..4.7 kΩ. Abaixo disso significa demasiados pull-ups ativos em paralelo.
Parâmetros do barramento I²C
- Endereço predefinido:
0x50(7 bits) - Intervalo de endereços:
0x08..0x77(reatribuível em fábrica) -
Velocidade recomendada em MicroPython + ESP32: 50 kHz — mitiga o padrão de NACK de base com o firmware v1 (ver a secção abaixo).
-
Velocidade recomendada em CPython + SBC Linux: 100 kHz (o padrão de NACK não aparece através do driver I²C do kernel — o caminho smbus2 do Linux não tem o problema de retry descrito para ESP-IDF).
-
Acesso a vários bytes: as leituras podem ser feitas em rajada (vários bytes numa transação); as escritas são byte a byte, cada uma com um endereço de registo explícito. O pacote faz isto corretamente por si; o código do utilizador nunca o vê.
Comprimento do barramento
O I²C é um barramento curto (~15 cm por predefinição). Muitos utilizadores ligam os módulos com fios de jumper de baixa qualidade, que captam muito ruído e perdem muitas transferências — daí o limite curto. Topologias recomendadas para o rbAmp:
| Cabo | Comprimento máximo | Velocidade |
|---|---|---|
| JST padrão / 4 condutores planos | até 0.15 m | 100 kHz |
| Par entrançado UTP (cat-5/5e/6) — SDA+GND e SCL+GND em pares separados | até 1 m | 100 kHz |
| Par entrançado + buffer I²C (PCA9515 / TCA9617) | até 3 m | 100 kHz |
| Barramento diferencial (PCA9615 / LTC4332) | até 100 m | 100 kHz |
Para comprimentos acima de 0.15 m, o par entrançado é obrigatório: SDA e SCL têm de estar em pares diferentes, cada um com a sua própria terra. SDA e SCL no mesmo par criam capacidade de acoplamento cruzado que distorce as transições.
⚠ Dentro de um armário elétrico, blinde o cabo I2C. Campos magnéticos fortes perto de condutores da rede, contactores e transformadores induzem ruído num cabo sem blindagem. Mantenha o cabo o mais curto possível e afastado da cablagem da rede.
Barramento multimódulo — a topologia principal
O caso de uso canónico da biblioteca são vários módulos rbAmp num único barramento I²C, geridos por um ESP32 / Raspberry Pi / SBC através de RbAmpFleet. Todas as regras e otimizações abaixo foram concebidas exatamente para esta topologia; um único módulo é um caso especial (o mesmo handle, mas as chamadas à frota degeneram em chamadas triviais).
Implementações típicas
| Cenário | Configuração | Número de módulos |
|---|---|---|
| 80 % canónico: entrada de serviço doméstica + contadores secundários | 1× UI1 (entrada, energia da rede) + 3-6× UI1/I1 (cargas) | 4-7 |
| Subquadro com repartição de corrente | 1× UI1 (entrada) + 1-2× I2/I3 (corrente por circuito) | 3-5 |
| Subcontagem industrial | 1× UI1 (entrada) + N× I2/I3 (por máquina, detalhe de corrente) | até ~16 |
Limites elétricos
- Número de módulos: até cerca de 16 (capacidade total do barramento ≤ 400 pF a 100 kHz; a 50 kHz a margem é maior).
- Pull-ups para o barramento da frota (importante): cada módulo vem com 4.7 kΩ incorporados. Num barramento com vários módulos, N pull-ups trabalham em paralelo → o sumidouro fica sobrecarregado e o barramento não consegue puxar para LOW. A partir de 4 módulos (ou antes, num barramento com mais de 15 cm) corte os pull-ups incorporados em todos os módulos menos um — com 2–3 módulos num barramento até 15 cm deixe-os, esse caso está medido (ou corte-os em todos e mantenha apenas um par externo (2.7…3.3 kΩ para 3 módulos, menos para barramentos maiores — ver a tabela acima) para 3.3 V num ponto do barramento — recomendado para linhas longas / ruído / ESP32 como mestre).
- Os pull-ups internos do ESP32 (~45 kΩ) são demasiado fracos para um barramento multi-módulo com comprimento de pista real — são necessários pull-ups externos (valores: ver a tabela acima). Faz parte da mitigação em três camadas contra bloqueio do barramento num barramento marginal — ver 10 · Resolução de problemas, secção "O script bloqueia / falha por timeout".
Endereçamento — provisionamento e substituição em campo (aprovado para produção)
O endereço de fábrica predefinido é 0x50. Cada módulo novo ou de substituição passa por provisionamento (uma vez): reendereçamento de 0x50 para um endereço de trabalho + gravação opcional da configuração (modelos TC, group_id, label) na flash. O modo de fábrica não é necessário — a mudança de endereço funciona diretamente em produção através de um commit em duas fases.
Método 1 — prepare_address_change / commit_address_change de baixo nível (API atual):
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 — o wrapper RbAmpFleet (recomendado para implementações de frota):
from rbamp import RbAmpFleet
fleet = RbAmpFleet(bus)
fleet.scan()
fleet.assign_address(dev, 0x52) # two-phase + reset + handle rebind
O protocolo de fios por baixo (para referência):
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
✅ Leitura de volta do endereço: REG_I2C_ADDRESS (0x30) no arranque lê o endereço ativo. Após o reboot pós-commit, ler 0x30 mostra o novo endereço ativo. Durante a preparação reflete o candidato até ao commit. A biblioteca garante que o estado de armação é limpo via try/finally em caso de falha parcial — RbAmpTimeoutError se a janela tiver expirado.
⚠ Disciplina de provisionamento — DEVE ser um virgem de cada vez.
A causa mais comum de falha de aprovisionamento é ter mais de um módulo com o endereço de fábrica 0x50 no barramento. Distingui-los por I²C é fisicamente impossível (dreno aberto com AND cablado — ambos os módulos fazem ACK de forma idêntica, e a releitura de dados fica "mesclada").
Daí que a regra seja estrita (um MUST normativo, não uma recomendação): no momento em que prepare_address_change() é chamado, tem de haver exatamente um módulo em 0x50 no barramento (um novo, ou um reposto às definições de fábrica através de uma ferramenta de bancada separada).
Caminho de recuperação se suspeitar de uma violação de disciplina: 1. Desligue e volte a ligar todos os módulos. 2. Desligue fisicamente todos menos um módulo "virgem". 3. Chame prepare_address_change() no barramento com um só módulo. 4. Acrescente os restantes módulos um de cada vez, configurando cada um separadamente.
Orçamento de energia do barramento
A 50 kHz, uma transação de leitura ≈ 200-400 µs. Um bloco RT completo para um canal (U + I + P + PF) ≈ 5-8 ms por canal.
| Configuração | Ciclo de barramento | A 50 kHz | Taxa máxima de consulta |
|---|---|---|---|
| 1× UI1, bloco RT | ~5 ms | < 5 ms | 100+ Hz (mas o módulo atualiza a 10 Hz) |
| 5× UI1, bloco RT | ~25 ms | ~25 ms | até 10 Hz |
| 16× I3, RT + período | ~400 ms | 400 ms > 100 ms | não consegue acompanhar o módulo (10 Hz); ~2 Hz na melhor das hipóteses |
Os números são estimativas.
Regra: a 50 kHz os limites confortáveis são 8-10× I3 ou 15-16× UI1 com polling a 5 Hz (cada segunda janela de módulo), e cerca de metade disso a 10 Hz completos.
Sincronização de período — sincronizar os períodos
Multi-módulo — snapshot simultâneo (period-metering) · 6.4 Sincronização de período — duas estratégias (api-reference)
Para medição tarifária, todos os módulos têm de fazer snapshot do mesmo intervalo.
Estratégia 1 — instantâneo sequencial + estabilização comum (qualquer 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]
Skew: 16 módulos × ~1 ms/snapshot = ~16 ms em relação a um período de 60 s = 0.027 %. Negligenciável para monitorização típica.
Estratégia 2 — snapshot por broadcast General-Call (requer ativação em cada módulo):
Todos os módulos tiram o seu snapshot numa única trama I²C no endereço 0x00:
addr=0x00 | A5 27 (5 bytes)
Skew = 0 (atómico). Pré-configuração (uma vez em cada módulo da frota):
dev.write_reg(0x27, 0x01)(define a flagGC_ENABLEde FLEET_CONFIG)dev.save_user_config()dev.reset()(estabilização ~300 ms)
Testemunha: para cada escravo esperado, leia REG_PERIOD_VALID (0x07). !=1 → recorra à estratégia 1.
⚠ Opt-in de GC (C.10): se o GC estiver desativado em toda a frota, o endereço GC dá NACK. O mestre recebe um erro duro (não uma perda silenciosa) — isto é detetável, não um bug.
Filtragem por grupo GC (barramento multi-inquilino)
REG_GROUP_ID (0x28) permite ter vários domínios GC num barramento:
group = 0x00→ chamada geral (all-call).group = N→ apenas os módulos comREG_GROUP_ID = Ntiram o instantâneo.
Caso de uso — separação de grupos tarifários.
Modos de falha
| Sintoma | Causa | O que fazer |
|---|---|---|
i2c bus scan mostra vários módulos no mesmo endereço após uma adição no terreno |
Um novo módulo em 0x50 está em conflito |
Reatribua-o separadamente antes de o adicionar |
| Um módulo responde com NACK com mais frequência do que os outros | Falha de cabo / queda de VCC | Verifique a VCC sob carga |
| Depois de uma trama GC, um módulo não tira o snapshot | GC_ENABLE de FLEET_CONFIG está desligado ou o grupo não coincide |
Verifique REG_FLEET_CONFIG e REG_GROUP_ID |
Os cenários detalhados com vários módulos estão em 06 · Exemplos.
Anfitriões CPython (SBC Linux + x86)
Raspberry Pi (qualquer modelo)
O barramento I²C 1 está encaminhado para o cabeçalho de 40 pinos. Na maioria dos modelos (1B+ / 2 / 3 / 4 / 5) os pinos são os mesmos:
| rbAmp | Cabeçalho de 40 pinos do RPi | GPIO (BCM) |
|---|---|---|
VCC |
pino 2 (+5V) | — |
GND |
pino 6 (ou qualquer GND) | — |
SDA |
pino 3 | GPIO 2 (SDA1) |
SCL |
pino 5 | GPIO 3 (SCL1) |
DRDY |
(optional) | qualquer GPIO livre com suporte a IRQ |
Ative o driver I²C do kernel: sudo raspi-config → 3 Interface Options → I2C → Yes. Ou edite manualmente /boot/firmware/config.txt (/boot/config.txt nas versões mais antigas do Raspberry Pi OS):
dtparam=i2c_arm=on
dtparam=i2c_arm_baudrate=100000 # 100 kHz (default 100 kHz)
Instale a ferramenta de scan e dê ao seu utilizador permissão para abrir o barramento (termine a sessão e volte a entrar depois), e depois verifique que o módulo responde:
sudo apt install i2c-tools
sudo usermod -aG i2c $USER
i2cdetect -y 1 # should show 0x50
Utilização a partir de Python:
from smbus2 import SMBus
from rbamp import RbAmp
with SMBus(1) as bus:
with RbAmp(bus, 0x50) as dev:
print(dev.voltage, "V")
Instalar smbus2: pip install smbus2 (ou o sistema sudo apt install python3-smbus).
Orange Pi 5 / Rock Pi 5 / outros SBC Linux
O mesmo smbus2.SMBus(N) em que N é o número do barramento de /dev/i2c-N. Normalmente /dev/i2c-1 ou /dev/i2c-0. Verifique:
ls /dev/i2c-*
i2cdetect -y 1 # should show 0x50
A pinagem depende da placa específica — consulte o seu datasheet.
x86 / Windows / macOS — via um dongle USB-I²C
Os hosts x86 não têm I²C nativo. A solução é um dongle USB-I²C (FT232H, MCP2221, Bus Pirate v4, CH341). O pyftdi.i2c.I2cController por si só não tem nem a assinatura compatível com smbus2 (read_byte_data / write_byte_data) nem a assinatura MicroPython (readfrom_mem / writeto_mem) — por isso não pode passá-lo diretamente a RbAmp(...); a autodeteção do barramento levantará RbAmpParamError.
Os dongles x86 precisam de uma classe invólucro fina que implemente a interface de backend de tipagem dinâmica (read_byte / write_byte / register_acks / now_ms — ver 09 · Referência da API, secção "Deteção automática do barramento"). Para outros dongles, escreva o seu próprio invólucro seguindo _io_smbus.py / _io_micropython.py.
Anfitriões 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 predefinidos (recomendado) | Porta I²C |
|---|---|---|
| ESP32 (original / WROOM / DevKitC) | GPIO 21 / GPIO 22 | I2C(0, ...) |
| ESP32-S2 | GPIO 21 / GPIO 22 (mesma convenção) | I2C(0, ...) |
| ESP32-S3 | GPIO 8 / GPIO 9 (predefinido para a placa N16R8) | I2C(0, ...) |
| ESP32-C3 | GPIO 5 / GPIO 6 | I2C(0, ...) |
Para outros chips, verifique o firmware MicroPython do seu 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")
O Pico não sofre do padrão de NACK de base — MachineI2CBackend deteta automaticamente o RP2040 e baixa o retry predefinido para 1 tentativa.
STM32 / Pyboard / Nucleo (via 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")
O STM32 não sofre do padrão de NACK de base — MachineI2CBackend baixa o valor predefinido de retry para 1 tentativa nestas placas.
Padrão de base NACK do MicroPython no ESP32 — 50 kHz
Ao correr em MicroPython num ESP32, o firmware rbAmp atual apresenta NACKs frequentes a 100 kHz, muito menos a 50 kHz. Isto é específico da pilha I²C do ESP-IDF que sustenta o MicroPython no ESP32. Nas outras portas MicroPython (RP2040 / STM32 / Pyboard) o problema não aparece.
O pacote trata isto em duas camadas:
-
Velocidade predefinida de 50 kHz — recomenda-se passar
freq=50_000amachine.I2C(...)no ESP32. -
Retry por byte em
MachineI2CBackend— 3 tentativas com intervalo de 5 ms por predefinição. Configurável através da API avançada:
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 mais sobre o diagnóstico de problemas ao nível do barramento, veja 10 · Resolução de problemas. Os contadores MachineI2CBackend.retry_exhaustion_count e RbAmp.sanity_reject_count estão disponíveis para observabilidade em soaks longos.
DATA_READY (DRDY)
Um pino opcional para otimizar o polling. Se a aplicação consultar o módulo no máximo uma vez a cada 100 ms, DRDY pode ficar desligado.
Parâmetros elétricos
- Tipo de saída: dreno aberto (sem pull-up ativa para VCC)
-
Nível de repouso: ALTO (requer um pull-up do lado do anfitrião — o pull-up integrado do GPIO ou uma resistência externa; recomendam-se 10 kΩ para 3.3 V)
-
Pulso de pronto: LOW durante ~10 µs depois de os registos RT terem sido atualizados com dados novos
-
Taxa de pulsos: ~10 Hz (um pulso por janela RT de ~100 ms)
Semântica
Uma transição de descida em DRDY garante que todos os registos RT estão sincronizados e publicados (o firmware atualiza-os de forma atómica na ISR antes de puxar o pino para baixo). Após a transição de descida, o mestre pode ler o bloco RT sem risco de obter uma amostra dividida.
Padrão de interrupção em 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))
Padrão em CPython (SBC Linux)
No Raspberry Pi via gpiozero ou 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 é opcional — o polling a qualquer taxa ≤ 10 Hz funciona também sem ele. O pacote não depende de DRDY em nenhum dos seus caminhos.
Módulos STANDARD (STD)
Os módulos STD usam a mesma ligação I²C, as mesmas considerações de pull-up, o mesmo endereço (predefinido 0x50) e os mesmos parâmetros de barramento descritos neste capítulo, e o mesmo construtor RbAmp(bus, addr). A biblioteca deteta a linha do módulo em begin(); não é necessária ligação ou configuração extra.
-
As chamadas exclusivas do STD (energia no dispositivo, ângulos de tensão, corrente de arranque, ...) levantam
RbAmpNotSupportedErrornum módulo BASIC. -
Algumas funcionalidades STD precisam de uma imagem de módulo suficientemente recente; numa imagem mais antiga a chamada lança
RbAmpNotSupportedError("not available"). -
As funcionalidades embutidas de energia, ângulo e corrente de arranque estão validadas em CPython (
smbus2). O caminho de 16 bits do MicroPython está implementado mas ainda não foi validado em hardware — prefira um host CPython (Raspberry Pi e outros SBC Linux, acima) para estas funcionalidades até que uma nota de versão diga o contrário.
Veja 09 · Referência da API.
Ligações
-
05 · Início rápido — o primeiro script para ambos os backends
-
06 · Exemplos — cenários de trabalho (incluindo o barramento multi-módulo e o streaming assíncrono)
-
09 · Referência da API — detalhes do backend e acessores dos contadores de retry/sanidade
-
10 · Resolução de problemas — depuração ao nível do barramento, o padrão de NACK, disciplina de retry + sanidade
Fonte e problemas: rb-amp/rbamp-python · esta página no repositório: docs/04_hardware.md (v1.6.1)