rbAmp
IT
Negozio
Docs
Aggiornato · Modifica su GitHub [Edit on GitHub]

04 · Cablaggio

Questo capitolo tratta il collegamento fisico del modulo rbAmp a un host Python: piedinatura del lato bassa tensione, requisiti di alimentazione, compatibilità dei livelli I²C, lunghezza del bus e i pin predefiniti per ciascun tipo di host. Gli host supportati sono CPython su SBC Linux e x86 + USB-I²C, e MicroPython su ESP32 / RP2040 / STM32 / Pyboard.

L'utente lavora solo con il lato a bassa tensione (BT: alimentazione + I²C + DRDY facoltativo); tutto ciò che tocca la rete rimane dentro l'involucro.

Sicurezza

⚠ Sicurezza di rete. La tensione di rete può essere letale. Scolleghi e blocchi il circuito prima di collegare i morsetti L/N o di montare la pinza; lasci il cablaggio di rete e ogni intervento dentro un quadro a una persona qualificata. Stringa un solo conduttore (L) — mai l'intero cavo (stringendo L e N si legge circa 0). La pinza stessa è senza contatto.

Cavo e fusibile (collegamento di tensione). AWG26–22 è sufficiente — il sensore di tensione assorbe pochissima corrente. Un fusibile sulla linea L è obbligatorio, da 0.1 A al massimo.

Pinout lato LV

Connettore a bassa tensione del modulo: VCC, GND, SDA, SCL e il pin DRDY facoltativo, con ciò che ciascuno richiede.

Il modulo funziona con logica I²C a 3.3 V ed è tollerante a 5 V sulle linee di segnale. Tutti i pin LV sono completamente isolati galvanicamente dalla rete.

Pin Segnale Scopo
VCC +5 V (4.5..5.5 V) Alimentazione del modulo; minimo 4.5 V per il corretto funzionamento
GND Terra Comune con l'host — obbligatorio
SDA I²C SDA Dati I²C
SCL I²C SCL Clock I²C
DRDY Dati pronti (opzionale) Drain aperto, impulso LOW di ~10 µs ogni ~100 ms

Potenza

Parametri VCC

  • Tensione nominale: 5 V DC
  • Intervallo consentito: 4.5..5.5 V
  • Corrente di alimentazione: ~15 mA tipici, ~25 mA di picco durante la scrittura in flash
  • Ripple: < 50 mV picco-picco (per la precisione di misura)

Il modulo ha un regolatore di bordo, un filtro RC, condensatori ceramici e una perlina di ferrite — non serve alcun filtraggio aggiuntivo da parte dell'utente. Può alimentare il modulo dal binario +5V o 5V0 di qualsiasi host (pin 2/4 del Raspberry Pi, USB-5V dell'ESP32 DevKitC, V+ del Pyboard, ecc.).

Compatibilità dei livelli I²C

  • SDA / SCL lavorano a logica 3.3 V (i pull-up integrati portano le linee a 3.3 V).

  • Le linee sono tolleranti a 5 V, ma tutti gli host citati sotto (Raspberry Pi / famiglia ESP32 / RP2040 / STM32 / Pyboard) lavorano già a logica 3.3 V — non servono convertitori di livello.

  • Il dongle USB-I²C pyftdi (FT232H / MCP2221) è anch'esso a logica 3.3 V — collegamento diretto.

Comportamento all'accensione

  • Avvio a freddo: ~250 ms fino al primo risultato valido.
  • Dopo un reset (software o brown-out): ~250 ms per riprendersi.
  • Fino al primo risultato valido, i registri leggono 0 e il flag DATA_VALID = 0.

Il pacchetto attende che il modulo sia pronto dentro dev.begin() — il codice utente chiama semplicemente begin() (oppure usa il context manager with RbAmp(bus, 0x50) as dev:, che chiama begin() automaticamente in __enter__).

Isolamento

Il modulo in sé è interamente a bassa tensione — non c'è alcun circuito di misura ad alta tensione. La corrente viene letta da una pinza TA che si accoppia magneticamente dall'esterno del conduttore isolato, senza alcun contatto elettrico con il filo di rete. Sulle varianti con misura di tensione (UI) l'unico riferimento di rete è il morsetto L–N, che alimenta un partitore di misura isolato galvanicamente*; le varianti solo-ampere non hanno alcun collegamento alla rete. Conseguenze:

  • Il GND del modulo non è collegato alla linea di rete né al neutro.
  • Collegare il lato bassa tensione all'host Python è sicuro — non c'è rischio di corto circuito attraverso la terra.
Sicurezza

⚠ Non apra l'involucro del modulo — così facendo si annulla la calibrazione di fabbrica.

Resistenze di pull-up integrate — sulla scheda

Importante: ogni modulo rbAmp è fornito con resistenze di pull-up integrate da 4.7 kΩ su SDA e SCL verso 3.3 V. Per un singolo modulo sul bus non servono pull-up esterni — collegare direttamente l'host.

Quando disattivare i pull-up integrati

Se sul bus ci sono più moduli rbAmp (o altri dispositivi I²C con i propri pull-up), collegarli in parallelo dà una resistenza effettiva troppo bassa, che:

  • Aumenta l'assorbimento di corrente del bus
  • Può superare la corrente massima di assorbimento dello stadio di uscita del master I²C
  • Aggiunge capacità su un bus lungo senza migliorare granché l'immunità al rumore

Soluzione: sul lato inferiore della scheda di ciascun modulo, accanto alle resistenze di pull-up, ci sono ponticelli saldati (serigrafia Pull-Up). Li tagli con una lama affilata:

  • Lasci i pull-up attivi su un solo modulo (oppure li sposti in un unico punto vicino all'host).

  • Tagli i ponticelli sugli altri moduli.

Regola pratica

Dove restano le resistenze di pull-up I²C per uno-tre moduli su un bus corto e per quattro o più, e come si tagliano i ponticelli di saldatura.

Moduli rbAmp sul bus Pull-up
1 Lasci così (i 4.7 kΩ integrati funzionano)
2 Tenere su uno, tagliare sull'altro
3 Tagli su tutti i moduli, monti una coppia esterna da 2.7…3.3 kΩ vicino all'host
4…6 Tagli su tutti i moduli, una coppia esterna da 2.2…2.7 kΩ vicino all'host
7…16 Taglio su tutti i moduli, una coppia esterna da 1.5…2.2 kΩ vicino all'host; controllare la capacità del bus (≤ 400 pF), abbassare la velocità del bus se necessario

I valori esterni sono valori consigliati (calcolati dalla specifica I²C: corrente di assorbimento ≤ 3 mA a 3.3 V, capacità del bus ≤ 400 pF). Collegare i pull-up esterni a 3.3 V (il livello logico del bus), non all'alimentazione VCC a 5 V.

In caso di dubbio

: misuri la resistenza tra SDA e VCC con i dispositivi spenti. Dovrebbe rientrare nell'intervallo 1.5..4.7 kΩ. Un valore inferiore significa troppi pull-up attivi in parallelo.

Parametri del bus I²C

  • Indirizzo predefinito: 0x50 (7 bit)
  • Intervallo di indirizzi: 0x08..0x77 (riassegnabile in fabbrica)
  • Velocità consigliata su MicroPython + ESP32: 50 kHz — attenua lo schema di NACK di base con il firmware v1 (vedere la sezione sotto).

  • Velocità consigliata su CPython + SBC Linux: 100 kHz (lo schema di NACK non compare attraverso il driver I²C del kernel — il percorso Linux smbus2 non ha il problema di retry descritto per ESP-IDF).

  • Accesso multi-byte: le letture possono avvenire a raffica (più byte in una transazione); le scritture avvengono byte per byte, ciascuna con un indirizzo di registro esplicito. Il pacchetto lo fa correttamente da solo; il codice utente non lo vede mai.

Lunghezza del bus

L'I²C è un bus corto (~15 cm di default). Molti utenti collegano i moduli con cavetti di bassa qualità, che captano molto rumore e perdono molti trasferimenti — da qui il limite breve. Topologie consigliate per rbAmp:

Cavo Lunghezza massima Velocità
JST standard / piatto a 4 conduttori fino a 0.15 m 100 kHz
Doppino intrecciato UTP (cat-5/5e/6) — SDA+GND e SCL+GND in coppie separate fino a 1 m 100 kHz
Coppia intrecciata + buffer I²C (PCA9515 / TCA9617) fino a 3 m 100 kHz
Bus differenziale (PCA9615 / LTC4332) fino a 100 m 100 kHz
Sicurezza

Per lunghezze superiori a 0.15 m, il doppino intrecciato è obbligatorio: SDA e SCL devono stare in coppie diverse, ciascuna con la propria massa. SDA e SCL nella stessa coppia creano una capacità di accoppiamento incrociato che distorce i fronti.

⚠ All'interno di un quadro elettrico, schermi il cavo I2C. Campi magnetici intensi vicino ai conduttori di rete, ai contattori e ai trasformatori inducono rumore in un cavo non schermato. Tenga il cavo il più corto possibile e lontano dai cablaggi di rete.

Bus multimodulo — la topologia principale

Il caso d'uso canonico della libreria è più moduli rbAmp su un unico bus I²C, gestiti da un solo ESP32 / Raspberry Pi / SBC tramite RbAmpFleet. Tutte le regole e le ottimizzazioni qui sotto sono pensate proprio per questa topologia; un singolo modulo è un caso particolare (stesso handle, ma le chiamate del fleet diventano banali).

Più moduli su un unico bus I²C con i pull-up integrati tagliati e una coppia esterna sul master, più le tre opzioni DRDY.

Installazioni tipiche

Scenario Configurazione Numero di moduli
Canone dell'80%: ingresso di servizio domestico + contatori secondari 1× UI1 (ingresso, energia di rete) + 3-6× UI1/I1 (carichi) 4-7
Sottoquadro con ripartizione della corrente 1× UI1 (ingresso) + 1-2× I2/I3 (corrente per circuito) 3-5
Sotto-misura industriale 1× UI1 (ingresso) + N× I2/I3 (per macchina, dettaglio di corrente) fino a ~16

Limiti elettrici

  • Numero di moduli: fino a circa 16 (capacità totale del bus ≤ 400 pF a 100 kHz; a 50 kHz il margine è maggiore).
  • Pull-up per il bus del fleet (importante): ogni modulo viene fornito con 4.7 kΩ integrati. Su un bus multi-modulo, N pull-up lavorano in parallelo → il sink è sovraccarico e il bus non riesce a scendere a LOW. Da 4 moduli in su (o già prima su un bus più lungo di 15 cm) tagli i pull-up integrati su tutti i moduli tranne uno — con 2–3 moduli su un bus fino a 15 cm li lasci, quel caso è misurato (oppure li tagli su tutti e tenga solo una coppia esterna (2.7…3.3 kΩ per 3 moduli, meno per bus più grandi — vedere la tabella sopra) verso 3.3 V in un punto del bus — consigliato per tratte lunghe / rumore / ESP32 come master).
  • I pull-up interni dell'ESP32 (~45 kΩ) sono troppo deboli per un bus multi-modulo con una lunghezza di traccia reale — servono pull-up esterni (valori: vedere la tabella sopra). Questo è parte della mitigazione a tre livelli contro il blocco del bus su un bus marginale — vedere 10 · Risoluzione dei problemi, sezione "Lo script si blocca / fallisce per timeout".

Indirizzamento — provisioning e sostituzione sul campo (adatto alla produzione)

Provisioning di un modulo alla volta: sul bus resta un solo modulo ancora all'indirizzo predefinito mentre gli viene assegnato l'indirizzo di lavoro.

L'indirizzo di fabbrica predefinito è 0x50. Ogni modulo nuovo o di ricambio passa per il provisioning (una volta): cambio di indirizzo da 0x50 a un indirizzo operativo + salvataggio opzionale della configurazione (modelli TA, group_id, etichetta) in flash. La modalità fabbrica non è richiesta — il cambio di indirizzo funziona direttamente in produzione tramite un commit in due fasi.

Metodo 1 — basso livello prepare_address_change / commit_address_change (API attuale):

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

Metodo 2 — il wrapper RbAmpFleet (consigliato per le installazioni a flotta):

Python
from rbamp import RbAmpFleet

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

Il protocollo a basso livello sul filo (per riferimento):

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
Sicurezza

✅ Rilettura dell'indirizzo: REG_I2C_ADDRESS (0x30) all'avvio legge l'indirizzo attivo. Dopo il reboot successivo al commit, leggendo 0x30 compare quello nuovo attivo. Durante la preparazione riflette il candidato fino al commit. La libreria garantisce che lo stato di armamento venga azzerato tramite try/finally in caso di errore parziale — RbAmpTimeoutError se la finestra è scaduta.

⚠ Disciplina di provisioning — DEVE essercene uno alla volta.

La causa più frequente di fallimento del provisioning è avere più di un modulo con l'indirizzo di fabbrica 0x50 sul bus. Distinguerli via I²C è fisicamente impossibile (open-drain con AND cablato — entrambi i moduli rispondono ACK in modo identico e la rilettura dei dati risulterà "fusa").

Quindi la regola è rigida (un MUST normativo, non una raccomandazione): nel momento in cui viene chiamato prepare_address_change(), deve esserci esattamente un modulo a 0x50 sul bus (uno nuovo, oppure uno riportato alle impostazioni di fabbrica con uno strumento da banco separato).

Percorso di ripristino se si sospetta una violazione della disciplina: 1. Spegnere e riaccendere tutti i moduli. 2. Scollegare fisicamente tutti i moduli tranne uno «vergine». 3. Chiamare prepare_address_change() sul bus con il solo modulo. 4. Aggiungere gli altri moduli uno alla volta, configurando ciascuno separatamente.

Bilancio energetico del bus

A 50 kHz una singola transazione di lettura ≈ 200-400 µs. Un blocco RT completo per un canale (U + I + P + PF) ≈ 5-8 ms per canale.

Configurazione Bus per ciclo A 50 kHz Frequenza massima di polling
1× UI1, blocco RT ~5 ms < 5 ms 100+ Hz (ma il modulo aggiorna a 10 Hz)
5× UI1, blocco RT ~25 ms ~25 ms fino a 10 Hz
16× I3, RT + periodo ~400 ms 400 ms > 100 ms non riesce a tenere il passo con il modulo (10 Hz); ~2 Hz al meglio
Nota

I numeri sono stime.

Regola: a 50 kHz i limiti comodi sono 8–10× I3 oppure 15–16× UI1 con interrogazione a 5 Hz (ogni secondo finestra di modulo), e circa la metà a 10 Hz pieni.

Sincronizzazione dei periodi — allineare i periodi

Per la misura tariffaria, tutti i moduli devono fare lo snapshot dello stesso intervallo.

Un comando di broadcast fa sì che tutti i moduli prendano lo snapshot di periodo nello stesso istante.

Strategia 1 — snapshot sequenziale + assestamento comune (qualsiasi 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]

Skew: 16 moduli × ~1 ms/istantanea = ~16 ms rispetto a un periodo di 60 s = 0.027%. Trascurabile per il monitoraggio tipico.

Strategia 2 — istantanea in broadcast General-Call (richiede l'attivazione su ciascun modulo):

Tutti i moduli prendono lo snapshot con un unico frame I²C all'indirizzo 0x00:

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

Skew = 0 (atomico). Pre-configurazione (una volta per ogni modulo del fleet):

  1. dev.write_reg(0x27, 0x01) (imposta il flag GC_ENABLE di FLEET_CONFIG)
  2. dev.save_user_config()
  3. dev.reset() (stabilizzazione ~300 ms)

Testimone: per ogni slave atteso, legga REG_PERIOD_VALID (0x07). !=1 → ricada sulla strategia 1.

Sicurezza

⚠ Adesione al GC (C.10): se il GC è disabilitato su tutto il fleet, l'indirizzo GC riceve NACK. Il master riceve un errore esplicito (non una perdita silenziosa) — questo è rilevabile, non un bug.

Filtro per gruppo GC (bus multi-tenant)

REG_GROUP_ID (0x28) permette di avere più domini GC su un bus:

  • group = 0x00 → chiamata generale.
  • group = N → solo i moduli con REG_GROUP_ID = N prendono lo snapshot.

Caso d'uso — separazione dei gruppi tariffari.

Modalità di guasto

Sintomo Causa Che cosa fare
i2c bus scan mostra più moduli allo stesso indirizzo dopo un'aggiunta sul campo Un nuovo modulo a 0x50 è in conflitto Lo riassegni separatamente prima di aggiungerlo
Un modulo risponde con NACK più spesso degli altri Guasto del cavo / calo della VCC Verifichi la VCC sotto carico
Dopo un frame GC, un modulo non prende lo snapshot GC_ENABLE di FLEET_CONFIG è disattivato oppure il gruppo non corrisponde Controlli REG_FLEET_CONFIG e REG_GROUP_ID

Gli scenari multi-modulo più dettagliati sono in 06 · Esempi.

Host CPython (SBC Linux + x86)

Raspberry Pi (qualsiasi modello)

Il bus I²C 1 è instradato sul connettore a 40 pin. Sulla maggior parte dei modelli (1B+ / 2 / 3 / 4 / 5) i pin sono gli stessi:

rbAmp Connettore a 40 pin RPi GPIO (BCM)
VCC pin 2 (+5V) —
GND pin 6 (o un GND qualsiasi) —
SDA pin 3 GPIO 2 (SDA1)
SCL pin 5 GPIO 3 (SCL1)
DRDY (optional) qualsiasi GPIO libero con supporto a interrupt

Attivi il driver I²C del kernel: sudo raspi-config → 3 Interface Options → I2C → Yes. Oppure modifichi a mano /boot/firmware/config.txt (/boot/config.txt sulle versioni più vecchie di Raspberry Pi OS):

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

Installi lo strumento di scansione e consenta al suo utente di aprire il bus (dopo esce e rientra dalla sessione), quindi verifichi che il modulo risponda:

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

Uso da 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")

Installazione di smbus2: pip install smbus2 (oppure quello di sistema sudo apt install python3-smbus).

Orange Pi 5 / Rock Pi 5 / altri SBC Linux

Lo stesso smbus2.SMBus(N) dove N è il numero di bus da /dev/i2c-N. Di solito /dev/i2c-1 o /dev/i2c-0. Verificare:

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

Il pinout dipende dalla specifica scheda — consultarne il datasheet.

x86 / Windows / macOS — tramite un dongle USB-I²C

Gli host x86 non hanno I²C nativo. La soluzione è un dongle USB-I²C (FT232H, MCP2221, Bus Pirate v4, CH341). pyftdi.i2c.I2cController da solo non ha né una firma compatibile con smbus2 (read_byte_data / write_byte_data) né una firma MicroPython (readfrom_mem / writeto_mem) — quindi non può essere passato direttamente a RbAmp(...); il rilevamento automatico del bus solleverà RbAmpParamError.

I dongle x86 richiedono un thin wrapper che implementi l'interfaccia di backend duck-typed (read_byte / write_byte / register_acks / now_ms — vedi 09 · Riferimento API, sezione «Rilevamento automatico del bus»). Per altri dongle, scrivere un proprio wrapper modellato su _io_smbus.py / _io_micropython.py.

Host 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 predefiniti (consigliati) Porta I²C
ESP32 (originale / WROOM / DevKitC) GPIO 21 / GPIO 22 I2C(0, ...)
ESP32-S2 GPIO 21 / GPIO 22 (stessa convenzione) I2C(0, ...)
ESP32-S3 GPIO 8 / GPIO 9 (predefiniti per la scheda N16R8) I2C(0, ...)
ESP32-C3 GPIO 5 / GPIO 6 I2C(0, ...)

Per altri chip, controllare il firmware MicroPython del proprio 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")

Il Pico non soffre dello schema di NACK di base — MachineI2CBackend riconosce automaticamente l'RP2040 e abbassa il valore predefinito dei tentativi a 1.

STM32 / Pyboard / Nucleo (tramite 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 non soffre dello schema di NACK di base — MachineI2CBackend riduce il tentativo predefinito a 1 su queste schede.

Schema di NACK di base su MicroPython con ESP32 — 50 kHz

Con MicroPython su ESP32, il firmware rbAmp attuale mostra NACK frequenti a 100 kHz, molto meno a 50 kHz. È specifico dello stack I²C ESP-IDF su cui si basa MicroPython su ESP32. Sulle altre porte MicroPython (RP2040 / STM32 / Pyboard) il problema non si presenta.

Il pacchetto affronta questo su due livelli:

  1. Velocità predefinita di 50 kHz — si consiglia di passare freq=50_000 a machine.I2C(...) su ESP32.

  2. Ripetizione per byte in MachineI2CBackend — 3 tentativi con pausa di 5 ms per default. Configurabile tramite l'API avanzata:

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

Per approfondire i problemi a livello di bus, vedi 10 · Risoluzione dei problemi. I contatori MachineI2CBackend.retry_exhaustion_count e RbAmp.sanity_reject_count sono disponibili per l'osservabilità nei soak prolungati.

DATA_READY (DRDY)

Un pin opzionale per l'ottimizzazione del polling. Se l'applicazione interroga il modulo non più di una volta ogni 100 ms, DRDY può restare non collegato.

Parametri elettrici

  • Tipo di uscita: drain aperto (nessuna pull-up attiva verso VCC)
  • Livello di riposo: ALTO (richiede un pull-up lato host — il pull-up integrato del GPIO o una resistenza esterna; si consigliano 10 kΩ verso 3.3 V)

  • Impulso di pronto: BASSO per ~10 µs dopo che i registri RT sono stati aggiornati con dati freschi

  • Frequenza degli impulsi: ~10 Hz (un impulso per finestra RT di ~100 ms)

Semantica

Un fronte di discesa su DRDY garantisce che tutti i registri RT siano sincronizzati e pubblicati (il firmware li aggiorna in modo atomico nell'ISR prima di abbassare il pin). Dopo il fronte di discesa il master può leggere il blocco RT senza rischio di campione spezzato.

Schema a interrupt su 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))

Schema su CPython (SBC Linux)

Sul Raspberry Pi tramite 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 è opzionale — l'interrogazione a qualsiasi frequenza ≤ 10 Hz funziona anche senza. Il pacchetto non dipende da DRDY in nessuno dei suoi percorsi.

Moduli STANDARD (STD)

I moduli STD usano lo stesso cablaggio I²C, le stesse considerazioni sui pull-up, lo stesso indirizzo (predefinito 0x50) e gli stessi parametri di bus descritti in questo capitolo, e lo stesso costruttore RbAmp(bus, addr). La libreria rileva la linea del modulo in begin(); non serve alcun cablaggio o configurazione aggiuntiva.

  • Le chiamate riservate allo STD (energia sul dispositivo, angoli di tensione, corrente di spunto, ...) sollevano RbAmpNotSupportedError su un modulo BASIC.

  • Alcune funzioni STD richiedono un'immagine del modulo abbastanza recente; su un'immagine più vecchia la chiamata solleva RbAmpNotSupportedError («non disponibile»).

  • Le funzioni on-device di energia, angolo e corrente di spunto sono validate su CPython (smbus2). Il percorso a 16 bit di MicroPython è implementato ma non ancora validato su hardware — per queste funzioni preferisca un host CPython (Raspberry Pi e altri SBC Linux, sopra) finché una nota di rilascio non dica diversamente.

Vedi 09 · Riferimento API.


Sorgente e segnalazioni: rb-amp/rbamp-python · questa pagina nel repo: docs/04_hardware.md (v1.6.1)