I2C_MCP23017 mit Trixie und Pi5 keine saubere Steuerung möglich

[Burny4600]

Man findet vieles über Änderungen betreffend Interrupt Steuerung für den MCP23017 im WEB, aber alles bisher Getestete sind Sackgassen was die GPIOs betrifft.
Derzeit stehe ich mit meinem Latein am Ende.
Haben sich betreffend Pi5 und Trixie bzw. GPIOs schon Lösungsansätze ergeben?

[frober]

Warum quälst du (ihr) euch damit rum?

Es wird schon lange empfohlen nicht die IO-Pins vom Raspi zu benutzen und zwar genau deswegen.
 
Nimm einen Arduino und binde ihn z.B. seriel an oder ein I2C-USB Adapter o.ä. Damit bist du unabhängig vom Raspi.

Ein ESP32 mit Tasmota oder ESHome usw. funktioniert genauso. Über WLan bist du sogar standortunabhängig.

[Burny4600]

Für solche Änderungen ist leider kein Platz im Verteiler vorhanden, bzw. sind alle USB-Schnittstellen schon belegt. Und alles komplett umzukrempeln ist dort auch keine Lösung. Alle anderen I2C-Verbindungen funktionieren dort.

Und wie soll der Interrupt des MCP23017 mit solchen Adaptern funktionieren?

[frober]

Muss jeder selbst entscheiden...

Umbau ist einmalig, die Probleme evtl. bei jedem Upgrade (HW o. SW).

Der "Adapter" erkennt normalerweise den Interrupt und sendet die Info über die Schnittstelle an den Raspi.

Z.B. ein ESP32 mit Tasmota/ESPHome mit WLan über MQTT.
Wobei der ESP ja I/O Pins hat und der MCP23017 evtl. sogar überflüssig ist.
Im Inet gibt's genug Lösungsansätze...

[Burny4600]

Der MCP23017 wird mehrfach in der Haustechnik seit 2018 verwendet. Ein wegfallen oder ersetzen ist icht möglich. Der Aufwand wäre sehr hoch. Ich benötige eine funktionsfähige Lösung Vorort.
USB kann ich noch mit eine USB-Switch erweitern. Nur eine funktionsfähige kompakte Lösung per USB mit dem MCP23017 die zukunftsicher ist kommt in Frage.

Zwei andere Pis die direkt mit den GPIOs betrieben werden, werde ich eine andere Lösung finden müssen.
Ich finde es nur schade, dass es mittels FHEM für die GPIOs keine wirkliche Lösung gibt bzw. eine Anpassung vollzogen wird.

Das einzige nicht so aufwendige und kostspielige wäre ein Waveshare USB to UART/I2C/SPI/JTAG Adapter.
Nur finde ich dazu unter FHEM noch keine Lösung für die Anbindung des MCP23017.

[Stelaku]

Du hast noch die Möglichkeit die GPIOs über Phyton auf der Shell ebene zu Steuern. Und dieses dann über mptt mit fhem verbinden. Habe einen Probeaufbau bei mir mit einen PI 4 und Trixi. Der alle GPIOs steuerbar macht und meine 8 mcps steuert. Natürlich funktioniert auch der interupt.
Dann wäre es ohne Hardware Änderungen möglich. Bei mir ist es genauso das eine  Hardware Änderungen nicht in Frage kommt. Nicht bei der Größe der Anlage. Es fängt ja immer klein an und ehe man sich versieht ist es schon groß geworden  das eine gewisse Abhängigkeit besteht.
Viele Grüße Stephan.
Aber vielleicht kommt Klaus ja noch dazu das rpi_gpio Modul so anzupassen das es wieder funktioniert.

[Burny4600]

Wie genau hast du das mit fhem mittes mptt gelöst?

[eisman]

hi,

ich benutze MCP23017-E/SP (Reichel) und hatte bisher damit keine Probleme,
mit dem Module MCP23017 dagegen, habe ich von 4 schon 3 in den
Müll geschmissen. RPI benutze ich mittlerweile nicht mehr. die alternativen
sind Preiswerter und zuverlässiger.

PS: eine MCP ist direkt unter einem ESP32S3 platziert und läuft ohne Probleme.

gruss

[frober]

...und die aktuelle Winringpi sollte auch funktionieren. Falls nicht ein Issue auf GitHub eröffnen.

[Burny4600]

Trixie ist neu installiert mit Winringpi V3.20.
Funktioniert aber nicht am Pi5.

[Stelaku]

Gib mir ein paar Tage ich schreib Mal alles zusammen was ich gemacht habe um das über mqtt zu lösen

[Stelaku]

Hallo Burny

hier eine kleine Auflistung wie ich das mit den GPIO´s per mqtt gelöst habe.

mit den aktiven user bei mir stephan paho-mqtt installieren

Code Auswählen Erweitern

sudo -u stephan pip3 install --break-system-packages paho-mqtt

dann habe ich eine Python Datei für meine Taster ( Eingänge ) im home Verzeichnis angelegt
username und password muss natürlich auf Deine angepasst werden.

Code Auswählen Erweitern

####################################################################
######                                                       #######
######                Taster.py Version 1.5                  #######
######                       mit gpiod                       #######
######            mqtt Client wird geöffnet und              #######
######            wenn ein Event der Input gpio              #######
######         erfasst wird sendet der mqtt client           #######
######         dieses an Fhem. Wenn dort noch kein           #######
######       MQTT2_GPIO device vorhanden ist wird es         #######
######          automatisch angelegt im MQTT Raum            #######
######        das script läuft mit nur sehr geringer         #######
######                      CPU Läst                         #######
######                                                       #######
######            Erstellt am 06.11.2026 und unter           #######
######              trixe erfolgreich getestet               #######
######                                                       #######
####################################################################

import logging
import paho.mqtt.client as mqtt

from datetime import timedelta
import gpiod
# Bias hinzugefügt, um interne Widerstände zu aktivieren
from gpiod.line import Direction, Edge, Bias

# mqtt Client öffnen
broker_address="localhost"
port = 1883
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2,"MQTT2_GPIO")
username = 'DEIN_USERNAME'
password = 'DEIN_PASSWORD'
client.username_pw_set(username, password)
client.connect(broker_address, port)

client.loop_start()

# Alle deine Taster-Pins
DEBOUNCED_PINS = [17, 27, 5, 19, 26, 21, 20, 12, 1, 7, 8, 18] 
RAW_PIN = 4               # Das ist der Interrupt für die MCPs

CHIP_PATH = "/dev/gpiochip0"

# Die Konfiguration wird für jeden Pin-Typ individuell erstellt
pin_config = {}

# 1. Konfiguration für die Taster (Mit Entprellung UND internem Pull-Up Widerstand)
for pin in DEBOUNCED_PINS:
    pin_config[pin] = gpiod.LineSettings(
        direction=Direction.INPUT,
        edge_detection=Edge.BOTH,
        bias=Bias.PULL_UP,                          # <- Aktiviert den internen Pull-Up Widerstand
        debounce_period=timedelta(milliseconds=10)  # Filtert Prellen unter 10ms
    )

# 2. Konfiguration für den nicht-entprellten Pin (Ebenfalls mit Pull-Up für den MCP-Interrupt)
pin_config[RAW_PIN] = gpiod.LineSettings(
    direction=Direction.INPUT,
    edge_detection=Edge.BOTH,
    bias=Bias.PULL_UP                               # <- Auch hier wird oft ein Pull-Up benötigt
)

try:
    with gpiod.request_lines(
        CHIP_PATH,
        consumer="DebounceSelector",
        config=pin_config
    ) as lines:

        while True:
            # Blockiert hocheffizient im Kernel
            if lines.wait_edge_events():
                for event in lines.read_edge_events():
                    triggered_pin = event.line_offset

                    # Korrekte Event-Typ-Bestimmung
                    if event.event_type == event.Type.RISING_EDGE:
                        state = "off"
                    elif event.event_type == event.Type.FALLING_EDGE:
                        state = "on"
                    else:
                        continue

                    # Senden an Fhem per MQTT
                    topic = f"GPIO{triggered_pin}"
                    client.publish(topic, state, 0)

except KeyboardInterrupt:
    print("\nProgramm sauber beendet.")
except PermissionError:
    print("\nFehler: Bitte mit 'sudo' starten!")




Für die Ausgänge eine seperate Datei ebenfalls im home Verzeichnis
username und password muss natürlich auch in dieser Deine angepasst werden.

Code Auswählen Erweitern



#!/usr/bin/env python3

######################################################################
######                                                          ######
######                       Output.py                          ######
######                erstellt am 06.11.2026                    ######
######   gpio´s werden mit gpiod aus Fhem per mqtt gesteuert    ######
######                                                          ######
######                    getestet unter Trixi                  ######
######                  funktioniert 06.11.2026                 ######
######                                                          ######
######################################################################

import logging
import gpiod
from gpiod.line import Direction, Value
import paho.mqtt.client as mqtt

# --- KONFIGURATION ---
MQTT_BROKER = "localhost"
MQTT_PORT = 1883
MQTT_TOPIC_SUBSCRIBE = "gpio/#"

# --- AUTHENTIFIZIERUNG ---
MQTT_USER = "DEIN_USERNAME"  # Hier den MQTT-Benutzernamen eintragen
MQTT_PASSWORD = "DEIN_PASSWORD"   # Hier das MQTT-Passwort eintragen

# Trage hier die GPIOs (BCM-Nummern) ein, die du steuern möchtest (z.B. 22, 23)
ALLOWED_GPIOS = [22, 10, 9, 11, 0, 6, 13, 16, 25, 24, 23, 15, 14]

# Nutze den vollen Pfad zum Chip.
# (Bei Raspberry Pi 4 meist "/dev/gpiochip0", bei Pi 5 meist "/dev/gpiochip4")
GPIO_CHIP_PATH = "/dev/gpiochip0"
# ---------------------

logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

# Globales Objekt für die angeforderten GPIO-Leitungen
gpio_request = None

def setup_gpios():
    """Initialisiert die GPIOs nach dem neuen gpiod v2.x Standard."""
    global gpio_request
    try:
        # Konfiguration für jeden erlaubten Pin erstellen (als Ausgang definieren)
        line_settings = {}
        for pin in ALLOWED_GPIOS:
            line_settings[pin] = gpiod.LineSettings(direction=Direction.OUTPUT)
           
        # Alle Leitungen gleichzeitig im System anfordern
        gpio_request = gpiod.request_lines(
            GPIO_CHIP_PATH,
            consumer="mqtt-gpiod-v2",
            config=line_settings
        )
        logging.info(f"GPIOs {ALLOWED_GPIOS} erfolgreich mit gpiod v2 initialisiert.")
    except Exception as e:
        logging.error(f"Fehler bei gpiod v2 Initialisierung: {e}")
        logging.error("TIPP: Prüfe, ob GPIO_CHIP_PATH korrekt ist (z.B. /dev/gpiochip4 statt /dev/gpiochip0)")
        raise

# Callback-Signatur angepasst an paho-mqtt v2 (enthält 'properties')
def on_connect(client, userdata, flags, rc, properties=None):
    # rc kann bei paho-mqtt v2 ein ReasonCode-Objekt sein, dessen Wert per .value abgefragt wird
    rc_value = rc.value if hasattr(rc, "value") else rc
   
    if rc_value == 0:
        logging.info("Erfolgreich mit MQTT Broker verbunden.")
        client.subscribe(MQTT_TOPIC_SUBSCRIBE)
        logging.info(f"Topic abonniert: {MQTT_TOPIC_SUBSCRIBE}")
    else:
        logging.error(f"Verbindungsfehler zum Broker. Code: {rc_value}")

def on_message(client, userdata, msg):
    global gpio_request
    topic = msg.topic
    parts = topic.split('/')
   
    # Validierung: Erwartet wird exakt "gpio/<nummer>/<aktion>"
    if len(parts) != 3 or parts[0] != "gpio":
        return
       
    pin_str = parts[1]
    action = parts[2].lower()

    try:
        pin = int(pin_str)
    except ValueError:
        return

    # Prüfen, ob der Pin erlaubt und initialisiert ist
    if pin not in ALLOWED_GPIOS or gpio_request is None:
        logging.warning(f"Pin {pin} ist nicht in ALLOWED_GPIOS konfiguriert.")
        return

    # Zustand bestimmen (ACTIVE = Strom an / INACTIVE = Strom aus)
    if action == "on":
        val = Value.ACTIVE
    elif action == "off":
        val = Value.INACTIVE
    else:
        logging.warning(f"Ungültige Aktion '{action}' erhalten. Erwartet: on/off")
        return

    # GPIO nach neuem v2-Standard schalten
    try:
        gpio_request.set_value(pin, val)
##        logging.info(f"GPIO {pin} erfolgreich auf {action.upper()} geschaltet.")
    except Exception as e:
        logging.error(f"Schaltfehler an Pin {pin}: {e}")

def main():
    setup_gpios()

    # Initialisierung kompatibel mit alten und neuen paho-mqtt Versionen (v1 & v2)
    try:
        # Versuche v2 API (erfordert Angabe der Callback-Version)
        client = mqtt.Client(callback_api_version=mqtt.CallbackAPIVersion.VERSION2)
    except AttributeError:
        # Fallback für ältere paho-mqtt Versionen v1.x
        client = mqtt.Client()

    client.on_connect = on_connect
    client.on_message = on_message

    # --- HIER WIRD DIE AUTHENTIFIZIERUNG GESETZT ---
    if MQTT_USER and MQTT_PASSWORD:
        client.username_pw_set(MQTT_USER, MQTT_PASSWORD)

    try:
        logging.info(f"Verbinde zu Broker {MQTT_BROKER} mit Benutzername '{MQTT_USER}'...")
        client.connect(MQTT_BROKER, MQTT_PORT, 60)
        client.loop_forever()
    except KeyboardInterrupt:
        logging.info("Skript manuell beendet.")
    finally:
        if gpio_request:
            logging.info("Schließe GPIO Leitungen...")
            gpio_request.release()

if __name__ == "__main__":
    main()

Damit beide Dateien auch bei jeden neustart mit gestartet werden hier meine systemd Datei die ich unter

Code Auswählen Erweitern

/etc/systemd/system/Output.service
/etc/systemd/system/Taster.service


gespeichert habe

hier die systendatei für Taster.py
auch hier user und WorkingDirectory auf Deine Werte ändern

Code Auswählen Erweitern

[Unit]
Description=Taster Eingänge für Fhem
After=network.target

[Service]
Type=simple
User=stephan
WorkingDirectory=/home/stephan
ExecStart=/usr/bin/python -u /home/stephan/Taster.py
Restart=on-failure
RestartSec=10s

[Install]
WantedBy=multi-user.target


Und die systemdatei für Output.py
auch hier user und WorkingDirectory auf Deine Werte ändern

Code Auswählen Erweitern

[Unit]
Description=Some description
After=network.target

[Service]
Type=simple
User=stephan
WorkingDirectory=/home/stephan
ExecStart=/usr/bin/python -u /home/stephan/Output.py
Restart=on-failure
RestartSec=10sec

[Install]
WantedBy=multi-user.target


diese müssen dann noch enabled werden mit

Code Auswählen Erweitern

sudo systemctl enable Taster.service
sudo systemctl enable Output.service

jetzt noch starten

Code Auswählen Erweitern

sudo systemctl start Taster.service
sudo systemctl start Output.service



jetzt sollte bei jeden Tasterevent ein weiteres Reading im Device MQTT2_GPIO erscheinen.
Mein MQTT2_GPIO Device sieht so aus. Das hat sich mit autocreate so selbst erstellt.

Code Auswählen Erweitern

define MQTT2_GPIO MQTT2_DEVICE MQTT2_GPIO
attr MQTT2_GPIO readingList MQTT2_GPIO:GPIO4:.* GPIO4\
MQTT2_GPIO:GPIO17:.* GPIO17\
MQTT2_GPIO:GPIO27:.* GPIO27\
MQTT2_GPIO:GPIO5:.* GPIO5\
MQTT2_GPIO:GPIO19:.* GPIO19\
MQTT2_GPIO:GPIO26:.* GPIO26\
MQTT2_GPIO:GPIO21:.* GPIO21\
MQTT2_GPIO:GPIO20:.* GPIO20\
MQTT2_GPIO:GPIO12:.* GPIO12\
MQTT2_GPIO:GPIO1:.* GPIO1\
MQTT2_GPIO:GPIO7:.* GPIO7\
MQTT2_GPIO:GPIO8:.* GPIO8\
MQTT2_GPIO:GPIO18:.* GPIO18\
MQTT2_GPIO:\x7bname\x7d:.* { json2nameValue($EVENT) }\
MQTT2_GPIO:name:.* name\
MQTT2_GPIO:GPIO\x7bgpio\x7d:.* GPIO_gpio_\
MQTT2_GPIO:gpio:.* gpio\
MQTT2_GPIO:\x7bgpio\x7d:.* _gpio_
attr MQTT2_GPIO room MQTT2_DEVICE
#   CID        MQTT2_GPIO
#   DEF        MQTT2_GPIO
#   FUUID      6a68c69a-f33f-134a-47f5-5bca089964e6a874
#   IODev      MQTT2_FHEM_Server
#   LASTInputDev MQTT2_FHEM_Server
#   MQTT2_FHEM_Server_CONN MQTT2_FHEM_Server_127.0.0.1_49103
#   MQTT2_FHEM_Server_MSGCNT 234
#   MQTT2_FHEM_Server_TIME 2026-11-07 12:48:01
#   MSGCNT     234
#   NAME       MQTT2_GPIO
#   NR         474
#   STATE      ???
#   TYPE       MQTT2_DEVICE
#   eventCount 234
#   READINGS:
#     2026-07-28 21:38:12   GPIO            off
#     2026-11-07 12:00:15   GPIO1           off
#     2026-11-07 12:00:13   GPIO12          off
#     2026-11-07 12:48:01   GPIO17          off
#     2026-11-07 12:00:18   GPIO18          off
#     2026-11-07 12:00:10   GPIO19          off
#     2026-11-07 12:00:12   GPIO20          off
#     2026-11-07 12:00:11   GPIO21          off
#     2026-11-07 12:00:10   GPIO26          off
#     2026-11-07 12:11:53   GPIO27          off
#     2026-11-07 11:52:50   GPIO4           off
#     2026-11-07 12:00:08   GPIO5           off
#     2026-11-07 12:00:16   GPIO7           off
#     2026-11-07 12:00:16   GPIO8           off
#     2026-07-30 19:44:52   GPIO_gpio_      on
#     2026-07-28 21:40:53   GPIOaus         off
#     2026-07-28 21:40:53   GPIOein         on
#     2026-11-07 11:25:12   IODev           MQTT2_FHEM_Server
#     2026-07-30 19:51:14   _gpio_          on
#     2026-07-28 21:52:24   _gpiozero.Button_object_on_pin_GPIO17__pull_up_True__is_active_False_ on
#     2026-07-30 19:48:28   gpio            on
#     2026-07-29 17:52:33   json2nameValueErrorText error parsing (#1) 'zustand'
#     2026-07-29 17:52:33   json2nameValueInput {zustand}
#     2026-07-29 17:54:44   name            zustand
#
setstate MQTT2_GPIO 2026-07-28 21:38:12 GPIO off
setstate MQTT2_GPIO 2026-11-07 12:00:15 GPIO1 off
setstate MQTT2_GPIO 2026-11-07 12:00:13 GPIO12 off
setstate MQTT2_GPIO 2026-11-07 12:48:01 GPIO17 off
setstate MQTT2_GPIO 2026-11-07 12:00:18 GPIO18 off
setstate MQTT2_GPIO 2026-11-07 12:00:10 GPIO19 off
setstate MQTT2_GPIO 2026-11-07 12:00:12 GPIO20 off
setstate MQTT2_GPIO 2026-11-07 12:00:11 GPIO21 off
setstate MQTT2_GPIO 2026-11-07 12:00:10 GPIO26 off
setstate MQTT2_GPIO 2026-11-07 12:11:53 GPIO27 off
setstate MQTT2_GPIO 2026-11-07 11:52:50 GPIO4 off
setstate MQTT2_GPIO 2026-11-07 12:00:08 GPIO5 off
setstate MQTT2_GPIO 2026-11-07 12:00:16 GPIO7 off
setstate MQTT2_GPIO 2026-11-07 12:00:16 GPIO8 off
setstate MQTT2_GPIO 2026-07-30 19:44:52 GPIO_gpio_ on
setstate MQTT2_GPIO 2026-07-28 21:40:53 GPIOaus off
setstate MQTT2_GPIO 2026-07-28 21:40:53 GPIOein on
setstate MQTT2_GPIO 2026-11-07 11:25:12 IODev MQTT2_FHEM_Server
setstate MQTT2_GPIO 2026-07-30 19:51:14 _gpio_ on
setstate MQTT2_GPIO 2026-07-28 21:52:24 _gpiozero.Button_object_on_pin_GPIO17__pull_up_True__is_active_False_ on
setstate MQTT2_GPIO 2026-07-30 19:48:28 gpio on
setstate MQTT2_GPIO 2026-07-29 17:52:33 json2nameValueErrorText error parsing (#1) 'zustand'
setstate MQTT2_GPIO 2026-07-29 17:52:33 json2nameValueInput {zustand}
setstate MQTT2_GPIO 2026-07-29 17:54:44 name zustand


alle Eingänge und Ausgänge habe ich bei mir dann mit readingproxy abgebildet.
Hier eine Device für einen GPIO Eingang.

Code Auswählen Erweitern

defmod GPIO17 readingsProxy MQTT2_GPIO:GPIO17
attr GPIO17 alias Taster_Stube_links
attr GPIO17 group GPIO Eingänge
attr GPIO17 room Eingänge
attr GPIO17 sortby 01
attr GPIO17 valueFn {($VALUE eq "on")?"on":"off"}


Und hier ein device für einen gpio Ausgang

Code Auswählen Erweitern

defmod GPIO13 MQTT2_DEVICE GPIO13
attr GPIO13 IODev MQTT2_FHEM_Server
attr GPIO13 alias Eltako_Bad_rechts
attr GPIO13 group GPIO Ausgänge
attr GPIO13 readingList MQTT2_FHEM_Server:GPIO13:.* state
attr GPIO13 room Ausgänge
attr GPIO13 setList off:noArg    gpio/13/off\
on:noArg     gpio/13/on
attr GPIO13 sortby 07
attr GPIO13 verbose 2


und hier das device für meinen Interrupt für die MCP´s

Code Auswählen Erweitern

defmod Interrupt readingsProxy MQTT2_GPIO:GPIO4
attr Interrupt group MCP23017
attr Interrupt room Bus
attr Interrupt userReadings test {fhem ("get MCP0,MCP2,MCP4,MCP6");;;;;;;; "egal"}
attr Interrupt valueFn {($VALUE eq "on")?"on":"off"}


Ich hoffe ich habe jetzt nichts vergessen und wünsche Dir viel Erfolg bei der Umsetzung.

Viele Grüße

Stephan