Zwei Sensoren an einem Bus
Was dieses Beispiel zeigt
Das Beispiel electrochemical-twoSensors.py liest zwei Boards am selben I2C-Bus aus und gibt beide Konzentrationen alle 2,5 Sekunden in Parts per Billion (ppb) aus. Es erzeugt pro Board ein Sensorobjekt, jeweils mit eigener Adresse: sensor1 mit adc_addr=0x4A und config_pin=25, sensor2 mit adc_addr=0x49 und config_pin=32.
Was dieses Board dafür braucht
Die Adressen des Beispiels, 0x4A und 0x49, sind ADS1115-Adressen, nicht die Bridge-Adressen des Boards. Bei einer Adresse außerhalb von 0x30 bis 0x37 läuft das Modul nicht über die Bridge: begin() sucht jeden ADS1115 mit einem I2C-Scan und schreibt die Konfiguration jedes LMP91000 an 0x48, auf dem Bus, den Sie übergeben. Die Kommentare im Beispiel verlangen an jedem Breakout eine andere ADC-Adresse, eingestellt mit den Adress-Jumpern, und für jedes Board ein LMPEN, das mit einem eigenen GPIO (25 und 32) verbunden ist, weil beide LMP91000-Chips die Adresse 0x48 teilen. Das Modul setzt jeden config_pin auf Low, während es die Konfiguration dieses Frontends schreibt, und sonst auf High.
Auf diesem Board liegen der ADS1115 und der LMP91000 am internen Bus, den die obere Stiftleiste als SDA2 und SCL2 herausführt; JP2 bis JP4 legen die Adresse des ADS1115 an diesem Bus fest. Die Qwiic-Connectors und SDA1/SCL1 erreichen nur die ATtiny404-Bridge, und ein I2C-Scan über Qwiic findet nur die Bridge, im Auslieferungszustand an 0x30. LMPEN liegt an der unteren Stiftleiste, ist über 10 kΩ auf GND gezogen und zusätzlich mit dem ATtiny404 verbunden.
Verbinden Sie daher für dieses Beispiel die obere Stiftleiste jedes Boards und nicht das Qwiic-Kabel: Schließen Sie SDA Ihres Controllers an SDA2 jedes Boards an, SCL an SCL2 jedes Boards, den 3,3-V-Pin an 3V3 und GND an GND. Das Anschlussdiagramm im Listing zeigt Qwiic-Leitungen, aber über Qwiic antwortet nur die Bridge jedes Boards.
Über Qwiic teilen sich zwei dieser Boards über ihre Bridges einen Bus: Jedes braucht eine eigene Adresse von 0x30 bis 0x37, eingestellt mit dem dreipoligen ADDRESS-DIP-Schalter, und ein eigenes Sensorobjekt mit dieser Adresse. Der Schalter und die Jumper sind auf Hardware-Details beschrieben.
Ändern Sie vor dem Ausführen SENSOR_O3 in der import-Zeile und in
beiden Zeilen, die einen Sensor erzeugen, in SENSOR_CO. SENSOR_O3 ist die
Voreinstellung des Moduls für die Ozonzelle. Dieses Board trägt die
Kohlenmonoxid-Zelle SGX-4CO, und die Voreinstellung des Moduls dafür ist
SENSOR_CO. Mit der Ozon-Voreinstellung rechnet das Modul beide Messwerte
mit Empfindlichkeit und Nullpunkt der Ozonzelle um, sodass die Zahlen keine
CO-Konzentrationen sind.
Das Beispiel öffnet I2C-Bus 0 mit SCL an Pin 22 und SDA an Pin 21. Ändern Sie diese auf die I2C-Pins Ihres Controllers, falls sie abweichen.
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)
Die folgenden Zeilen stammen aus einem Lauf dieses Beispiels mit zwei Boards an einem Bus, die jeweils wie oben beschrieben über die Pins SDA2, SCL2, 3V3 und GND ihrer Stiftleiste mit dem Controller verbunden sind.
Erwartetes Ergebnis in der Thonny-Shell:
Electrochemical Gas Sensor - Two Sensors Example
Sensor 1 initialized successfully!
Sensor 2 initialized successfully!
Sensor 1 reading: 300.14804 PPB
Sensor 2 reading: 305.31076 PPB
Sensor 1 reading: 324.66712 PPB
Sensor 2 reading: 295.80346 PPB
Sensor 1 reading: 309.60049 PPB
Sensor 2 reading: 291.51048 PPB
Danach alle 2,5 Sekunden zwei Zeilen, Sensor 1 reading: und Sensor 2 reading: , jeweils mit der Konzentration in ppb auf fünf Dezimalstellen und PPB. Ein Ergebnis unter null wird als 0.00000 ausgegeben. Startet ein Board nicht, zeigt die Shell ERROR: Can't init sensor 1! Check connections! (oder sensor 2) an, und das Skript hält dort an.
Verwendete Funktionen
ElectrochemicalGasSensor(sensor_type, i2c=None, adc_addr=0x49, config_pin=None)returns ElectrochemicalGasSensorErzeugt ein Sensorobjekt. Das Beispiel ruft es zweimal am selben I2C-Bus auf, einmal pro Board, jeweils mit der Voreinstellung, dem gemeinsamen Bus, einer ADS1115-Adresse (0x4A, dann 0x49) und einem config_pin.
ReturnsDas Sensorobjekt.
Parameter
| Parameter | Typ | Beschreibung |
|---|---|---|
sensor_type | SensorConfig | Die Voreinstellung der Zelle. Für die SGX-4CO-Zelle dieses Boards ist die Voreinstellung des Moduls SENSOR_CO. |
i2c | machine.I2C | Ein initialisierter I2C-Bus, hier von beiden Objekten gemeinsam genutzt. Mit None öffnet das Modul I2C 0 an den Pins 22 und 21 bei einem ESP32 oder an den Pins 5 und 4 bei einem ESP8266 und löst auf jedem anderen Board Board not recognized, please pass an I2C object manually aus. |
adc_addr | int | Die I2C-Adresse. Standard 0x49. Von 0x30 bis 0x37 spricht das Modul mit der ATtiny404-Bridge des Boards. |
config_pin | int oder None | Ein GPIO, den das Modul auf Low setzt, während es die Konfiguration des Frontends sendet, und sonst auf High. Bei einer Adresse von 0x30 bis 0x37 nicht verwendet. Standard None. |
begin()returns boolStartet einen Sensor. Bei einer adc_addr von 0x30 bis 0x37 prüft es, ob die Bridge antwortet, sendet ihr Verstärkung und Datenrate des ADC aus der Voreinstellung und dann die Konfiguration des Frontends, wobei ein Busfehler bei jedem Schritt bis zu einem Timeout von 500 ms wiederholt wird. Bei jeder anderen adc_addr prüft es, ob der ADC an dieser Adresse antwortet, stellt dessen Verstärkung und Datenrate ein und schreibt dann die Konfiguration des Frontends, während der config_pin dieses Objekts auf Low gehalten wird.
ReturnsTrue, wenn jeder Schritt erfolgreich war, sonst False.
getPPB()returns floatFührt eine Messung am Board dieses Objekts durch und gibt sie in Parts per Billion zurück.
ReturnsgetPPM() multipliziert mit 1000.
Zusammenfügen
Geben Sie jedem Board eine eigene Adresse, erzeugen Sie pro Board ein Objekt am gemeinsamen Bus mit SENSOR_CO und dieser Adresse, rufen Sie begin() bei jedem auf und prüfen Sie das Ergebnis, und lesen Sie dann jedes Objekt in Ihrer Schleife mit getPPB() aus. Die Adressen des Beispiels sind ADS1115-Adressen, jeweils mit einem config_pin an LMPEN dieses Boards; über die Bridges der Boards sind es die Adressen ihrer ADDRESS-Schalter, von 0x30 bis 0x37, und es wird kein config_pin verwendet.