Zwei Sensoren an einem Bus auslesen
Was dieses Beispiel zeigt
Das Beispiel electrochemical-twoSensors.py des Moduls liest zwei Boards an einem
I2C-Bus aus. Es erzeugt pro Board ein Sensorobjekt, startet beide und gibt alle 2,5 Sekunden
beide Konzentrationen in ppb (parts per billion) aus.
Das Beispiel erzeugt sensor1 mit adc_addr=0x4A und config_pin=25 sowie
sensor2 mit adc_addr=0x49 und config_pin=32. Die beiden Sensoren unterscheiden sich
also in ihrer Adresse und ihrem LMPEN-Pin.
Die Kommentare des Beispiels verbinden den LMPEN jedes Boards mit dem GPIO, den es als
config_pin übergibt, 25 und 32. Auf diesem Board ist LMPEN der Enable-Eingang des LMP91000
an der unteren Stiftleiste und zusätzlich mit dem ATtiny404 des Boards verbunden (siehe die
Pin-Tabelle auf der Seite Hardware-Details).
Beide Sensoren verwenden das Ozon-Preset SENSOR_O3. SENSOR_NO2 ist das Preset des Moduls
für die SGX-4NO2-Zelle dieses Boards; ändern Sie es in der import-Zeile und in
beiden Zeilen, die einen Sensor erzeugen. Das Beispiel öffnet I2C-Bus 0 mit SCL an Pin
22 und SDA an Pin 21; passen Sie diese an Ihren Controller an.
Der Beispielcode
# FILE: electrochemical-twoSensors.py
# AUTHOR: Fran Fodor @ Soldered
# BRIEF: Two O3 sensor PPB reading example using two breakouts on one I2C bus.
# LAST UPDATED: 2026-05-21
# Connecting diagram:
#
# Qwiic------------------------>Qwiic
# LMPEN------------------------>25 (GPIO pin, required for I2C configuration)
#
# Qwiic------------------------>Qwiic (same bus)
# LMPEN------------------------>32 (GPIO pin, required for I2C configuration)
#
# Set different ADC I2C addresses on each breakout using the address jumpers.
# Both LMP91000 chips share address 0x48 — the LMPEN pin selects which one
# is active during configuration, so a GPIO pin is required for each sensor.
from machine import I2C, Pin
import time
from ElectrochemicalGasSensor import ElectrochemicalGasSensor, SENSOR_O3
# Initialize shared I2C bus
i2c = I2C(0, scl=Pin(22), sda=Pin(21))
# Sensor 1: ADC address 0x4A, LMPEN on pin 25
sensor1 = ElectrochemicalGasSensor(SENSOR_O3, i2c, adc_addr=0x4A, config_pin=25)
# Sensor 2: ADC address 0x49, LMPEN on pin 32
sensor2 = ElectrochemicalGasSensor(SENSOR_O3, i2c, adc_addr=0x49, config_pin=32)
# -------------------------------------------------------------------------
# Setup
# -------------------------------------------------------------------------
print("Electrochemical Gas Sensor - Two Sensors Example")
if not sensor1.begin():
print("ERROR: Can't init sensor 1! Check connections!")
while True:
time.sleep_ms(100)
print("Sensor 1 initialized successfully!")
if not sensor2.begin():
print("ERROR: Can't init sensor 2! Check connections!")
while True:
time.sleep_ms(100)
print("Sensor 2 initialized successfully!")
# -------------------------------------------------------------------------
# Main loop
# -------------------------------------------------------------------------
while True:
reading1 = sensor1.getPPB()
reading2 = sensor2.getPPB()
print("Sensor 1 reading: {:.5f} PPB".format(reading1))
print("Sensor 2 reading: {:.5f} PPB".format(reading2))
time.sleep_ms(2500)
🔗Vollständiges Beispiel öffnen
Examples/electrochemical-twoSensors.py im Commit 623e1e6
Erwartetes Ergebnis:
Electrochemical Gas Sensor - Two Sensors Example
Sensor 1 initialized successfully!
Sensor 2 initialized successfully!
Danach gibt das Beispiel alle 2,5 Sekunden zwei Zeilen aus, eine beginnend mit
Sensor 1 reading: und eine mit Sensor 2 reading:, jeweils gefolgt von der
Konzentration des jeweiligen Boards in ppb mit fünf Nachkommastellen. Startet ein Board nicht, gibt es
ERROR: Can't init sensor 1! Check connections! aus (bzw. sensor 2) und
wartet in einer Schleife.
Verwendete Funktionen
ElectrochemicalGasSensor(sensor_type, i2c=None, adc_addr=0x49, config_pin=None)returns ElectrochemicalGasSensorErzeugt ein Sensorobjekt. Mit einem config_pin setzt es diesen Pin außerdem als Ausgang und schaltet ihn auf High. Über I2C wird nichts gesendet, bis Sie begin() aufrufen. Das Beispiel erzeugt zwei, eines pro Board, am selben I2C-Objekt.
ReturnsDas Sensorobjekt.
Parameter
| Typ | Name | Beschreibung |
|---|---|---|
SensorConfig | sensor_type | Das Preset der Zelle. SENSOR_NO2 ist das Preset für die SGX-4NO2-Zelle dieses Boards. |
I2C | i2c | Der I2C-Bus, den beide Sensoren im Beispiel gemeinsam nutzen. Bei None wählt das Modul die Pins anhand des von MicroPython gemeldeten Ports: I2C-Bus 0 an den Pins 22 (SCL) und 21 (SDA) beim ESP32-Port, scl=Pin(5), sda=Pin(4) beim ESP8266-Port. Bei einem nicht erkannten Port löst es Board not recognized, please pass an I2C object manually aus. |
int | adc_addr | Die Adresse, mit der begin() kommuniziert, standardmäßig 0x49; das Beispiel übergibt 0x4A und 0x49. Von 0x30 bis 0x37 sendet das Modul seine Befehle an den ATtiny404; von 0x48 bis 0x4B spricht es den ADS1115 an adc_addr und den LMP91000 direkt an. |
int | config_pin | GPIO-Nummer für den Enable-Pin des LMP91000 (LMPEN), nur bei 0x48 bis 0x4B verwendet. Standardmäßig None; das Beispiel übergibt 25 und 32. |
sensor.begin()returns boolStartet einen Sensor und schreibt das Preset in ihn. Bei 0x30 bis 0x37 prüft es, ob der ATtiny404 antwortet, und sendet dann Verstärkung und Datenrate des ADC sowie die Konfiguration des LMP91000, wobei jeder Schritt wiederholt wird, bis das Board antwortet oder 500 ms vergangen sind. Bei 0x48 bis 0x4B prüft es, ob der ADS1115 bei adc_addr in einem I2C-Scan erscheint, stellt dessen Verstärkung und seine langsamste Datenrate ein und schreibt die Konfiguration in den LMP91000 bei 0x48, wobei es config_pin auf Low zieht. Rufen Sie es einmal für jeden Sensor auf, bevor Sie auslesen.
ReturnsTrue, wenn jeder Schritt erfolgreich war, andernfalls False.
sensor.getPPB()returns floatNimmt einen neuen Messwert von einem Sensor auf und gibt dessen Gaskonzentration in Parts per Billion zurück: getPPM() multipliziert mit 1000. Ein negatives Ergebnis wird als 0.0 zurückgegeben.
ReturnsDie Gaskonzentration in ppb.
Zusammenspiel
Beide Sensorobjekte teilen sich ein I2C-Objekt und unterscheiden sich in ihrer Adresse und
ihrem LMPEN-Pin. Das Beispiel startet sensor1, dann sensor2, und bleibt in einer Schleife
beim ersten stehen, der fehlschlägt. Jeder Durchlauf der Hauptschleife liest beide Sensoren
mit getPPB() aus, gibt die beiden Werte mit fünf Nachkommastellen aus und wartet 2,5
Sekunden.