04 · Câblage
Ce chapitre traite du raccordement physique du module rbAmp à un hôte Python : brochage côté basse tension, exigences d'alimentation, compatibilité de niveau I²C, longueur du bus, et broches par défaut de chaque type d'hôte. Les hôtes pris en charge sont CPython sur les SBC Linux et x86 + USB-I²C, et MicroPython sur ESP32 / RP2040 / STM32 / Pyboard.
L'utilisateur ne travaille que côté basse tension (BT) (alimentation + I²C + DRDY optionnel) ; tout ce qui touche au secteur reste à l'intérieur du boîtier.
⚠ Sécurité secteur. La tension du secteur peut tuer. Coupez et verrouillez le circuit avant de raccorder les bornes L/N ou de poser la pince ; confiez le câblage secteur et tout travail dans un tableau à une personne qualifiée. Serrez un seul conducteur (L) — jamais le câble entier (serrer L et N donne environ 0). La pince elle-même est sans contact.
Fil et fusible (connexion tension). AWG26–22 suffit — le capteur de tension consomme très peu de courant. Un fusible sur la ligne L est obligatoire, calibre jusqu'à 0.1 A.
Brochage côté basse tension
Le module fonctionne en logique I²C 3.3 V et tolère 5 V sur les lignes de signal. Toutes les broches basse tension sont entièrement isolées galvaniquement du secteur.
| Broche | Signal | Objet |
|---|---|---|
VCC |
+5 V (4.5..5.5 V) | Alimentation du module ; minimum 4.5 V pour un fonctionnement correct |
GND |
Terre | Commun avec l'hôte — obligatoire |
SDA |
SDA I²C | Données I²C |
SCL |
I²C SCL | Horloge I²C |
DRDY |
Données prêtes (facultatif) | Drain ouvert, impulsion LOW d'environ 10 µs toutes les ~100 ms |
Puissance
Paramètres de VCC
- Tension nominale : 5 V CC
- Plage admise : 4.5..5.5 V
- Courant d'alimentation : ~15 mA typique, ~25 mA en pointe lors de l'écriture en flash
- Ondulation : < 50 mV crête à crête (pour la précision de mesure)
Le module embarque un régulateur, un filtre RC, des condensateurs céramiques et une perle de ferrite — aucun filtrage supplémentaire n'est requis de l'utilisateur. Vous pouvez alimenter le module depuis le rail +5V ou 5V0 de tout hôte (broche 2/4 du Raspberry Pi, USB-5V d'un ESP32 DevKitC, V+ d'un Pyboard, etc.).
Compatibilité des niveaux I²C
-
SDA/SCLfonctionnent en logique 3.3 V (les tirages intégrés les ramènent à 3.3 V). -
Les lignes sont tolérantes au 5 V, mais tous les hôtes cités ci-dessous (Raspberry Pi / famille ESP32 / RP2040 / STM32 / Pyboard) travaillent déjà en logique 3.3 V — aucun convertisseur de niveau n'est nécessaire.
-
Le dongle USB-I²C
pyftdi(FT232H / MCP2221) est aussi en logique 3.3 V — connexion directe.
Comportement à la mise sous tension
- Démarrage à froid : ~250 ms jusqu'au premier résultat valide.
- Après une réinitialisation (logicielle ou coupure de tension) : environ 250 ms pour reprendre.
- Jusqu'au premier résultat valide, les registres lisent
0et l'indicateurDATA_VALID= 0.
Le paquet attend que le module soit prêt à l'intérieur de dev.begin() — le code utilisateur appelle simplement begin() (ou utilise le gestionnaire de contexte with RbAmp(bus, 0x50) as dev:, qui appelle begin() automatiquement dans __enter__).
Isolation
Le module lui-même est entièrement basse tension — il n'y a aucun circuit de mesure haute tension. Le courant est lu par une pince CT qui se couple magnétiquement depuis l'extérieur du conducteur isolé, sans contact électrique avec le fil du secteur. Sur les variantes à mesure de tension (UI), la référence secteur unique est la borne L–N, qui alimente un diviseur de détection isolé galvaniquement* ; les variantes ampèremétriques n'ont aucune connexion au secteur. Conséquences :
- Le
GNDdu module n'est pas relié au conducteur de phase ni au neutre. - Relier le côté basse tension au système Python est sans danger — aucun risque de court-circuit par la terre.
⚠ N'ouvrez pas le boîtier du module — cela annule l'étalonnage d'usine.
Résistances de tirage intégrées — sur la carte
Important : chaque module rbAmp est livré avec des résistances de pull-up intégrées de 4.7 kΩ sur SDA et SCL vers 3.3 V. Pour un seul module sur le bus, aucune pull-up externe n'est nécessaire — branchez directement l'hôte.
Quand désactiver les résistances de rappel intégrées
Si plusieurs modules rbAmp sont sur le bus (ou d'autres périphériques I²C avec leurs propres tirages), les relier en parallèle donne une résistance effective trop faible, ce qui :
- Augmente la consommation de courant du bus
- Peut dépasser le courant de puits maximal de l'étage de sortie du maître I²C
- Ajoute une charge capacitive sur un long bus sans améliorer beaucoup l'immunité au bruit
Solution : sur la face inférieure de la carte de chaque module, à côté des résistances de tirage, se trouvent des straps de soudure (sérigraphie Pull-Up). Coupez-les avec une lame bien affûtée :
-
Laissez les tirages activés sur un seul module (ou déplacez-les vers un point unique proche de l'hôte).
-
Coupez les straps sur les modules restants.
Règle empirique
| modules rbAmp sur le bus | Résistances de rappel |
|---|---|
| 1 | Laisser tel quel (les 4.7 kΩ intégrés suffisent) |
| 2 | Garder sur l'un, couper sur l'autre |
| 3 | Couper sur tous les modules, poser une paire externe 2.7…3.3 kΩ près de l'hôte |
| 4…6 | Couper sur tous les modules, poser une paire externe 2.2…2.7 kΩ près de l'hôte |
| 7…16 | Coupez sur tous les modules, une paire externe de 1.5…2.2 kΩ près de l'hôte ; vérifiez la capacité du bus (≤ 400 pF), abaissez la vitesse du bus si nécessaire |
Les valeurs externes sont des valeurs recommandées (calculées à partir de la spécification I²C : courant absorbé ≤ 3 mA à 3.3 V, capacité du bus ≤ 400 pF). Reliez les résistances de rappel externes à 3.3 V (le niveau logique du bus), et non à l'alimentation VCC 5 V.
: mesurez la résistance entre SDA et VCC, appareils hors tension. Elle doit se situer dans la plage 1.5..4.7 kΩ. Une valeur inférieure signifie trop de tirages actifs en parallèle.
Paramètres du bus I²C
- Adresse par défaut :
0x50(7 bits) - Plage d'adresses :
0x08..0x77(réassignable en usine) -
Vitesse recommandée sous MicroPython + ESP32 : 50 kHz — atténue le motif de NACK de base avec le firmware v1 (voir la section ci-dessous).
-
Vitesse recommandée sur CPython + SBC Linux : 100 kHz (le schéma NACK n'apparaît pas via le pilote I²C du noyau — le chemin smbus2 sous Linux n'a pas le problème de nouvelles tentatives décrit pour ESP-IDF).
-
Accès multi-octets : les lectures peuvent se faire en rafale (plusieurs octets en une transaction) ; les écritures se font octet par octet, chacune avec une adresse de registre explicite. Le paquet le fait correctement de lui-même ; le code utilisateur ne le voit jamais.
Longueur du bus
I²C est un bus court (environ 15 cm par défaut). Beaucoup d'utilisateurs connectent les modules avec des fils de liaison de mauvaise qualité, qui captent beaucoup de bruit et perdent de nombreux transferts — d'où la limite courte. Topologies recommandées pour rbAmp :
| Câble | Longueur maximale | Vitesse |
|---|---|---|
| JST standard / 4 conducteurs plats | jusqu'à 0.15 m | 100 kHz |
| Paire torsadée UTP (cat-5/5e/6) — SDA+GND et SCL+GND dans des paires séparées | jusqu'à 1 m | 100 kHz |
| Paire torsadée + tampon I²C (PCA9515 / TCA9617) | jusqu'à 3 m | 100 kHz |
| Bus différentiel (PCA9615 / LTC4332) | jusqu'à 100 m | 100 kHz |
Pour des longueurs supérieures à 0.15 m, la paire torsadée est obligatoire : SDA et SCL doivent être dans des paires différentes, chacune avec sa propre masse. SDA et SCL dans la même paire créent une capacité de couplage qui déforme les fronts.
⚠ Dans une armoire électrique, blindez le câble I2C. Les champs magnétiques intenses près des conducteurs secteur, des contacteurs et des transformateurs induisent du bruit dans un câble non blindé. Gardez le câble aussi court que possible et à l'écart du câblage secteur.
Bus multi-modules — la topologie principale
Le cas d'usage canonique de la bibliothèque est plusieurs modules rbAmp sur un seul bus I²C, gérés par un ESP32 / Raspberry Pi / SBC via RbAmpFleet. Toutes les règles et optimisations ci-dessous sont conçues pour cette topologie exacte ; un module unique est un cas particulier (même descripteur, mais les appels de flotte deviennent triviaux).
Déploiements types
| Scénario | Configuration | Nombre de modules |
|---|---|---|
| Canon 80 % : arrivée de service domestique + sous-compteurs | 1× UI1 (entrée, énergie du secteur) + 3-6× UI1/I1 (charges) | 4-7 |
| Sous-tableau avec répartition du courant | 1× UI1 (entrée) + 1-2× I2/I3 (courant par circuit) | 3-5 |
| Sous-comptage industriel | 1× UI1 (entrée) + N× I2/I3 (par machine, détail du courant) | jusqu'à environ 16 |
Limites électriques
- Nombre de modules : jusqu'à environ 16 (capacité totale du bus ≤ 400 pF à 100 kHz ; à 50 kHz la marge est plus grande).
- Tirages pour le bus de la flotte (important) : chaque module est livré avec 4.7 kΩ intégrés. Sur un bus multi-modules, N tirages travaillent en parallèle → le puits est surchargé et le bus ne peut pas tirer vers le bas jusqu'au niveau BAS. À partir de 4 modules (ou plus tôt sur un bus de plus de 15 cm), coupez les tirages intégrés sur tous les modules sauf un — avec 2 à 3 modules sur un bus de 15 cm maximum, laissez-les tels quels, ce cas est mesuré (ou coupez-les sur tous et ne gardez qu'une paire externe (2.7…3.3 kΩ pour 3 modules, plus faible pour des bus plus grands — voir le tableau ci-dessus) vers 3.3 V en un point du bus — recommandé pour les longues liaisons / le bruit / l'ESP32 en maître).
- Les tirages internes de l'ESP32 (~45 kΩ) sont trop faibles pour un bus multi-modules de longueur réelle — des tirages externes sont nécessaires (valeurs : voir le tableau ci-dessus). Cela fait partie de l'atténuation en trois couches contre le blocage du bus sur un bus limite — voir 10 · Dépannage, section « Le script se bloque / échoue sur dépassement de délai ».
Adressage — provisionnement et remplacement à chaud (compatible production)
L'adresse d'usine par défaut est 0x50. Chaque module neuf ou de remplacement passe par le provisionnement (une seule fois) : changement d'adresse de 0x50 vers une adresse de travail + sauvegarde facultative de la configuration (modèles de CT, group_id, étiquette) en flash. Le mode usine n'est pas requis — le changement d'adresse fonctionne directement en production grâce à un commit en deux phases.
Méthode 1 — bas niveau prepare_address_change / commit_address_change (API actuelle) :
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éthode 2 — l'enveloppe RbAmpFleet (recommandée pour les déploiements en flotte) :
from rbamp import RbAmpFleet
fleet = RbAmpFleet(bus)
fleet.scan()
fleet.assign_address(dev, 0x52) # two-phase + reset + handle rebind
Le protocole filaire sous-jacent (à titre de référence) :
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
✅ Relecture de l'adresse : REG_I2C_ADDRESS (0x30) au démarrage lit l'adresse active. Après le redémarrage consécutif à la validation, la lecture de 0x30 affiche la nouvelle adresse active. Pendant la préparation, elle reprend le candidat jusqu'à la validation. La bibliothèque garantit que l'état d'armement est effacé via try/finally en cas d'échec partiel — RbAmpTimeoutError si la fenêtre a expiré.
⚠ Discipline de provisionnement — UN SEUL module vierge à la fois, OBLIGATOIREMENT.
La cause la plus fréquente d'échec de provisionnement est d'avoir plus d'un module à l'adresse d'usine 0x50 sur le bus. Les distinguer par I²C est physiquement impossible (drain ouvert, ET câblé — les deux modules répondent ACK de la même façon, et la relecture des données sera « fusionnée »).
D'où une règle stricte (une exigence normative DOIT, et non une recommandation) : au moment où prepare_address_change() est appelé, il doit y avoir exactement un module à 0x50 sur le bus (un neuf, ou un remis aux réglages d'usine par un outil de banc distinct).
Procédure de reprise si vous soupçonnez une violation de la discipline : 1. Coupez l'alimentation de tous les modules. 2. Débranchez physiquement tous les modules sauf un « vierge ». 3. Appelez prepare_address_change() sur le bus à un seul module. 4. Ajoutez les modules restants un par un, en les provisionnant chacun séparément.
Bilan énergétique du bus
À 50 kHz, une transaction de lecture ≈ 200-400 µs. Un bloc temps réel complet pour un canal (U + I + P + PF) ≈ 5-8 ms par canal.
| Configuration | Bus par cycle | À 50 kHz | Cadence d'interrogation maximale |
|---|---|---|---|
| 1× UI1, bloc RT | ~5 ms | < 5 ms | 100+ Hz (mais le module se met à jour à 10 Hz) |
| 5× UI1, bloc RT | ~25 ms | ~25 ms | jusqu'à 10 Hz |
| 16× I3, temps réel + période | ~400 ms | 400 ms > 100 ms | ne suit pas le module (10 Hz) ; ~2 Hz au mieux |
Les chiffres sont des estimations.
Règle : à 50 kHz, les limites confortables sont 8-10× I3 ou 15-16× UI1 avec une scrutation à 5 Hz (chaque seconde fenêtre de module), et environ la moitié de cela à 10 Hz complets.
Synchronisation des périodes — aligner les périodes
Multi-module — instantané simultané (mesure par période) · 6.4 Synchronisation de période — deux stratégies (référence API)
Pour la mesure tarifaire, tous les modules doivent faire l'instantané sur le même intervalle.
Stratégie 1 — instantané séquentiel + stabilisation commune (tout 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]
Décalage : 16 modules × ~1 ms/instantané = ~16 ms par rapport à une période de 60 s = 0.027 %. Négligeable pour une surveillance classique.
Stratégie 2 — instantané par diffusion General-Call (nécessite l'activation sur chaque module) :
Tous les modules prennent leur instantané sur une seule trame I²C à l'adresse 0x00 :
addr=0x00 | A5 27 (5 bytes)
Décalage = 0 (atomique). Préconfiguration (une fois sur chaque module de la flotte) :
dev.write_reg(0x27, 0x01)(positionne le drapeauGC_ENABLEde FLEET_CONFIG)dev.save_user_config()dev.reset()(stabilisation ~300 ms)
Témoin : pour chaque esclave attendu, lisez REG_PERIOD_VALID (0x07). !=1 → repli sur la stratégie 1.
⚠ Activation GC optionnelle (C.10) : si GC est désactivé sur toute la flotte, l'adresse GC reçoit des NACK. Le maître obtient une erreur franche (et non un rejet silencieux) — c'est détectable, pas un bogue.
Filtrage par groupe GC (bus multi-locataires)
REG_GROUP_ID (0x28) permet d'avoir plusieurs domaines GC sur un même bus :
group = 0x00→ tous les appelés.group = N→ seuls les modules avecREG_GROUP_ID = Nprennent l'instantané.
Cas d'usage — séparation des groupes tarifaires.
Modes de défaillance
| Symptôme | Cause | Que faire |
|---|---|---|
i2c bus scan montre plusieurs modules à la même adresse après un ajout sur site |
Un nouveau module à 0x50 est en conflit |
Réadressez-le séparément avant de l'ajouter |
| Un module répond NACK plus souvent que les autres | Défaut de câble / chute de VCC | Vérifiez la VCC sous charge |
| Après une trame GC, un module ne prend pas l'instantané | GC_ENABLE de FLEET_CONFIG est désactivé ou le groupe ne correspond pas |
Vérifiez REG_FLEET_CONFIG et REG_GROUP_ID |
Les scénarios multi-modules détaillés se trouvent dans 06 · Exemples.
Hôtes CPython (SBC Linux + x86)
Raspberry Pi (tout modèle)
Le bus I²C 1 est routé vers le connecteur 40 broches. Sur la plupart des modèles (1B+ / 2 / 3 / 4 / 5), les broches sont identiques :
| rbAmp | En-tête 40 broches RPi | GPIO (BCM) |
|---|---|---|
VCC |
broche 2 (+5 V) | — |
GND |
broche 6 (ou n'importe quelle masse GND) | — |
SDA |
broche 3 | GPIO 2 (SDA1) |
SCL |
broche 5 | GPIO 3 (SCL1) |
DRDY |
(optional) | n'importe quel GPIO libre avec prise en charge des interruptions |
Activez le pilote I²C du noyau : sudo raspi-config → 3 Interface Options → I2C → Yes. Ou modifiez manuellement /boot/firmware/config.txt (/boot/config.txt sur les anciennes versions de Raspberry Pi OS) :
dtparam=i2c_arm=on
dtparam=i2c_arm_baudrate=100000 # 100 kHz (default 100 kHz)
Installez l'outil de scan et autorisez votre utilisateur à ouvrir le bus (déconnectez-vous puis reconnectez-vous ensuite), puis vérifiez que le module répond :
sudo apt install i2c-tools
sudo usermod -aG i2c $USER
i2cdetect -y 1 # should show 0x50
Usage depuis Python :
from smbus2 import SMBus
from rbamp import RbAmp
with SMBus(1) as bus:
with RbAmp(bus, 0x50) as dev:
print(dev.voltage, "V")
Installer smbus2 : pip install smbus2 (ou le paquet système sudo apt install python3-smbus).
Orange Pi 5 / Rock Pi 5 / autres SBC Linux
Le même smbus2.SMBus(N) où N est le numéro de bus de /dev/i2c-N. Généralement /dev/i2c-1 ou /dev/i2c-0. Vérifiez :
ls /dev/i2c-*
i2cdetect -y 1 # should show 0x50
Le brochage dépend de la carte précise — consultez sa fiche technique.
x86 / Windows / macOS — via un dongle USB-I²C
Il n'y a pas d'I²C natif sur les hôtes x86. La solution est un dongle USB-I²C (FT232H, MCP2221, Bus Pirate v4, CH341). pyftdi.i2c.I2cController seul n'a ni une signature compatible smbus2 (read_byte_data / write_byte_data) ni une signature MicroPython (readfrom_mem / writeto_mem) — on ne peut donc pas le passer directement à RbAmp(...) ; la détection automatique du bus lèvera RbAmpParamError.
Les dongles x86 nécessitent une fine classe d'enveloppe qui implémente l'interface de backend à typage canard (read_byte / write_byte / register_acks / now_ms — voir 09 · Référence API, section « Détection automatique du bus »). Pour d'autres dongles, écrivez votre propre enveloppe en vous inspirant de _io_smbus.py / _io_micropython.py.
Hôtes 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")
| Puce | SDA / SCL par défaut (recommandé) | Port I²C |
|---|---|---|
| ESP32 (original / WROOM / DevKitC) | GPIO 21 / GPIO 22 | I2C(0, ...) |
| ESP32-S2 | GPIO 21 / GPIO 22 (même convention) | I2C(0, ...) |
| ESP32-S3 | GPIO 8 / GPIO 9 (par défaut pour la carte N16R8) | I2C(0, ...) |
| ESP32-C3 | GPIO 5 / GPIO 6 | I2C(0, ...) |
Pour d'autres puces, vérifiez le firmware MicroPython de votre 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")
Le Pico ne subit pas le motif de NACK de base — MachineI2CBackend détecte automatiquement le RP2040 et ramène la valeur par défaut des tentatives à 1.
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")
Le STM32 ne subit pas le schéma de NACK de référence — MachineI2CBackend ramène la valeur par défaut des nouvelles tentatives à 1 sur ces cartes.
Schéma NACK de référence MicroPython sur ESP32 — 50 kHz
Sous MicroPython sur ESP32, le firmware rbAmp actuel présente des NACK fréquents à 100 kHz, bien moins à 50 kHz. C'est propre à la pile I²C ESP-IDF qui sous-tend MicroPython ESP32. Sur les autres ports MicroPython (RP2040 / STM32 / Pyboard) le problème n'apparaît pas.
Le paquet traite cela en deux couches :
-
Vitesse par défaut de 50 kHz — il est recommandé de passer
freq=50_000àmachine.I2C(...)sur ESP32. -
Nouvelle tentative par octet dans
MachineI2CBackend— 3 essais × intervalle de 5 ms par défaut. Configurable via l'API avancée :
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
Pour diagnostiquer plus avant les problèmes au niveau du bus, voir 10 · Dépannage. Les compteurs MachineI2CBackend.retry_exhaustion_count et RbAmp.sanity_reject_count sont disponibles pour l'observabilité des essais de longue durée.
DATA_READY (DRDY)
Une broche facultative pour optimiser la scrutation. Si l'application interroge le module au plus une fois toutes les 100 ms, DRDY peut rester non connecté.
Paramètres électriques
- Type de sortie : drain ouvert (pas de rappel actif vers VCC)
-
Niveau au repos : HAUT (nécessite une pull-up côté hôte — la pull-up intégrée du GPIO ou une résistance externe ; 10 kΩ vers 3.3 V recommandé)
-
Impulsion de disponibilité : BAS pendant ~10 µs après la mise à jour des registres RT avec des données fraîches
-
Cadence d'impulsions : ~10 Hz (une impulsion par fenêtre RT d'environ 100 ms)
Sémantique
Un front descendant sur DRDY garantit que tous les registres temps réel sont synchronisés et publiés (le firmware les met à jour de façon atomique dans l'ISR avant de tirer la broche vers le bas). Après le front descendant, le maître peut lire le bloc temps réel sans risque d'obtenir un échantillon scindé.
Schéma d'interruption sur 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))
Schéma sur CPython (SBC Linux)
Sur le 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 est facultatif — la scrutation à n'importe quelle cadence ≤ 10 Hz fonctionne aussi sans lui. Le paquet ne dépend de DRDY dans aucun de ses chemins.
Modules STANDARD (STD)
Les modules STD utilisent le même câblage I²C, mêmes considérations de tirage, même adresse (par défaut 0x50) et mêmes paramètres de bus que décrits dans ce chapitre, et le même constructeur RbAmp(bus, addr). La bibliothèque détecte la gamme dans begin() ; aucun câblage ni configuration supplémentaire n'est nécessaire.
-
Les appels réservés au STD (énergie embarquée, angles de tension, courant de démarrage, ...) lèvent
RbAmpNotSupportedErrorsur un module BASIC. -
Certaines fonctions STD exigent une image de module assez récente ; sur une image plus ancienne, l'appel lève
RbAmpNotSupportedError(« non disponible »). -
Les fonctions embarquées d'énergie, d'angle et de courant de démarrage sont validées sous CPython (
smbus2). Le chemin 16 bits de MicroPython est implémenté mais pas encore validé sur matériel — privilégiez un hôte CPython (Raspberry Pi et autres SBC Linux, ci-dessus) pour ces fonctions tant qu'une note de version n'indique pas le contraire.
Voir 09 · Référence API.
Liens
-
05 · Démarrage rapide — le premier script fonctionnel pour les deux environnements
-
06 · Exemples — scénarios de travail (dont le bus multi-modules + streaming asynchrone)
-
09 · Référence API — détails du backend et accesseurs des compteurs de nouvelles tentatives et de contrôle de cohérence
-
10 · Dépannage — débogage au niveau du bus, motif des NACK, discipline nouvelle tentative + cohérence
Sources et problèmes : rb-amp/rbamp-python · cette page dans le dépôt : docs/04_hardware.md (v1.6.1)