{"id":3638,"date":"2026-02-25T07:54:08","date_gmt":"2026-02-25T06:54:08","guid":{"rendered":"https:\/\/staging.elv.eqxt.de\/?p=3638"},"modified":"2026-06-12T12:34:50","modified_gmt":"2026-06-12T10:34:50","slug":"raspberry-pi-gpio-eingaben-taster-encoder-matrix","status":"publish","type":"post","link":"https:\/\/de.elv.com\/elvjournal\/raspberry-pi-gpio-eingaben-taster-encoder-matrix\/","title":{"rendered":"Einstieg in Python (Teil 7): Dateneingabe und Tastensteuerung"},"content":{"rendered":"\n

Einstieg in Python (Teil 7)<\/strong><\/p>\n\n\n\n

Dateneingabe und Tastensteuerung<\/h1>\n\n\n\n

Der Raspberry Pi eignet sich hervorragend f\u00fcr die Interaktion mit verschiedenen Eingabeger\u00e4ten. Ob einfache Taster oder komplexere Eingabeeinheiten wie Rotary Encoder und Matrix-Tastaturen \u2013 die M\u00f6glichkeiten, den Raspberry Pi mit der realen Welt zu verkn\u00fcpfen, sind vielf\u00e4ltig. In diesem Artikel sollen drei wichtige Arten von Eingabeger\u00e4ten f\u00fcr den Raspberry Pi n\u00e4her betrachtet werden: Taster\/Druckkn\u00f6pfe bzw. Schalter, Rotary Encoder und Matrix-Tastaturen mit bis zu 16 Tasten.<\/strong><\/p>\n\n\n\n

<\/div>\n\n\n\n

Eingabeger\u00e4te<\/h2>\n\n\n\n

Druckkn\u00f6pfe und Schalter geh\u00f6ren zu den grundlegendsten und am h\u00e4ufigsten verwendeten Eingabeeinheiten. Sie sind ideal f\u00fcr einfache Steuerungsfunktionen wie das Ein- und Ausschalten von Ger\u00e4ten oder das Starten bestimmter Programme oder Programmteile.<\/p>\n\n\n\n

Rotary Encoder dagegen erlauben die Erfassung kontinuierlicher Drehbewegungen. Dabei kann sowohl die Richtung als auch die Geschwindigkeit der Drehung erfasst werden. Diese Komponenten eignen sich daher perfekt f\u00fcr Anwendungen in der Robotik, der Maschinensteuerung oder als Scroll-R\u00e4der f\u00fcr die Men\u00fcauswahl in komplexeren Programmen.<\/p>\n\n\n\n

Matrix-Tastaturen sind n\u00fctzlich, wenn mehrere Eingabetasten ben\u00f6tigt werden. Sie bestehen aus einer Anordnung von Tasten, die in Zeilen und Spalten organisiert sind. Eine 4×4-Matrix-Tastatur zum Beispiel bietet 16 Tasten, die sich auf vier Zeilen und vier Spalten verteilen. Sie eigenen sich zum Bau von Zugangssicherungen, Geldautomaten, Fernbedienungen oder Telefonanlagen etc.<\/p>\n\n\n\n

Egal ob einfache Druckkn\u00f6pfe, Rotary Encoder f\u00fcr pr\u00e4zise Steuerungen oder Matrix-Tastaturen mit mehreren Tasten zum Einsatz kommen sollen \u2013 mit dem passenden Python-Programm und einem Raspberry Pi lassen sich diese Eingabeger\u00e4te problemlos anschlie\u00dfen und vielseitig nutzen.<\/p>\n\n\n\n

<\/div>\n\n\n\n
\n
\n

RPi.GPIO oder GPIOZero?<\/h2>\n\n\n\n

F\u00fcr die Ansteuerung der Pins stehen beim Raspberry Pi zwei Python-Bibliotheken, RPi.GPIO und GPIOZero, zur Verf\u00fcgung. Beide erm\u00f6glichen einen effizienten Einsatz der GPIO-Pins (General Purpose Input\/Output) des Raspberry Pi. Sie haben aber unterschiedliche Ans\u00e4tze und Zielgruppen. Ein Vergleich der beiden Bibliotheken zeigt die Unterschiede:<\/p>\n\n\n\n

    \n
  • RPi.GPIO:<\/strong>
    Diese Library ist \u00e4lter und erfordert mehr manuelle Konfiguration und Programmierung, was f\u00fcr Anf\u00e4nger schwieriger sein kann. Der Code f\u00fcr die Einrichtung eines GPIO-Pins, um eine LED einzuschalten, sieht so aus:\n\t\t\n\t\n
    import RPi.GPIO as GPIO\nGPIO.setmode(GPIO.BCM)\nGPIO.setup(18, GPIO.OUT)\nGPIO.output(18, GPIO.HIGH)<\/code><\/pre>\n<\/li>\n\n\n\n
  • GPIOZero:<\/strong>
    Diese Bibliothek wurde entwickelt, um die Nutzung der GPIO-Pins so einfach wie m\u00f6glich zu gestalten, und ist besonders f\u00fcr Anf\u00e4nger geeignet. Sie bietet eine hohe Abstraktionsebene, sodass viele Aufgaben mit weniger Code erledigt werden k\u00f6nnen. Der Beispielcode f\u00fcr die gleiche Aufgabe wie oben sieht so aus:\n\t\t\n\t\n
    from gpiozero import LED\nled = LED(18)\nled.on()<\/code><\/pre>\n<\/li>\n<\/ul>\n<\/div>\n<\/div>\n\n\n\n
    Bei RPi.GPIO muss der Benutzer alle GPIO-Einstellungen explizit festlegen. RPi.GPIO bietet somit eine sehr genaue Kontrolle \u00fcber jedes Detail, wie z. B. das Setzen von Pull-up- oder Pull-down-Widerst\u00e4nden und das Handling von GPIO-Interrupts. Diese Feinsteuerung erfordert aber mehr Codezeilen und ein besseres Verst\u00e4ndnis der GPIO-Hardware.<\/p>\n\n\n\n
    GPIOZero abstrahiert viele dieser technischen Details, sodass einfache Aktionen wie das Schalten einer LED oder das Lesen eines Buttons mit weniger Code durchgef\u00fchrt werden k\u00f6nnen. Komplexere Aktionen k\u00f6nnen durch Kapselung in leicht zu verwendende Klassen und Methoden erledigt werden. F\u00fcr einfache Projekte, bei denen es darum geht, schnell mit Hardware zu interagieren, ist GPIOZero die bessere Wahl. Wer hingegen komplexere oder speziellere Anforderungen hat, ist mit RPi.GPIO m\u00f6glicherweise besser bedient.<\/p>\n\n\n\n
    Die RPi.GPIO-Bibliothek ist eine der \u00e4ltesten und am weitesten verbreiteten GPIO-Bibliotheken f\u00fcr den Raspberry Pi, und es gibt derzeit keine offizielle Ank\u00fcndigung, dass sie \u201eaussterben“ k\u00f6nnte oder nicht mehr unterst\u00fctzt wird. Allerdings gibt es einige Trends und \u00dcberlegungen, die in der Zukunft relevant sein k\u00f6nnten. RPi.GPIO wird sicher nicht in K\u00fcrze vollkommen verschwinden, aber die Library k\u00f6nnte allm\u00e4hlich an Bedeutung verlieren. Die Bibliothek ist seit vielen Jahren unver\u00e4ndert und bietet eine sehr grundlegende, aber stabile Funktionalit\u00e4t. Da sie \u00e4lter ist, wird sie m\u00f6glicherweise nicht mehr aktiv weiterentwickelt, insbesondere wenn neue Modelle oder Hardware\u00e4nderungen beim Raspberry Pi auftreten.<\/p>\n\n\n\n
    Auf dem Raspberry Pi 5 ist GPIOZero bereits die bevorzugte Bibliothek f\u00fcr die GPIO-Steuerung, da sie vielseitiger und einfacher zu bedienen ist. Wer also noch die alte RPi.GPIO-Bibliothek verwenden sollte, muss auf \u00e4ltere Pi-Modelle zur\u00fcckgreifen. GPIOZero ist somit aus heutiger Sicht die zukunftssichere Variante. Aus diesem Grund wird im Folgenden auch die GPIOZero-Version im Vordergrund stehen.<\/p>\n\n\n\n
    <\/div>\n\n\n\n
    Alles auf Knopfdruck<\/h2>\n\n\n\n
    Ein Druckknopfschalter schlie\u00dft den Stromkreis nur, wenn er gedr\u00fcckt wird, w\u00e4hrend ein klassischer Schalter seinen Zustand beh\u00e4lt, bis er manuell wieder ver\u00e4ndert wird. Beide Komponenten k\u00f6nnen mit GPIO-Pins des Raspberry Pi verbunden werden und sind leicht mit Python auslesbar.<\/p>\n\n\n\n
    \n
    \n
    Mit der GPIOZero-Bibliothek ist das Einlesen von Drucktastern mit dem Raspberry Pi besonders einfach und benutzerfreundlich. Die Library vereinfacht den Umgang mit der GPIO-Hardware erheblich, sodass man mit minimalem Code auskommt. Bild 1 <\/mark>zeigt, wie ein Taster mit dem Raspberry Pi verbunden werden kann. Die einfachste Konfiguration ist, einen Pin des Tasters mit einem GPIO-Pin des Raspberry Pi und den anderen Pin des Tasters mit GND zu verbinden. Wenn der Taster gedr\u00fcckt wird, wird der GPIO-Pin auf LOW (0 V) gezogen, andernfalls bleibt er auf HIGH (3,3 V). Diese Konfiguration wird deshalb auch als \u201eLOW“-Aktiv bezeichnet.<\/p>\n<\/div>\n\n\n\n
    \n
    \"Bild
    Bild 1: Taster und LED am Raspberry Pi<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
    Das folgende Programm zeigt, wie man einen Tasterzustand einlesen kann (Button.py):<\/p>\n\n\n\n
    <\/div>\n\n\n\n
    from gpiozero import Button\nfrom signal import pause\n\nbutton = Button(4)\ndef on_button_press():\n    print(\"Taste gedr\u00fcckt!\")\n\nbutton.when_pressed = on_button_press\npause()<\/code><\/pre>\n\n\n\n
    In diesem Beispiel wird ein Button-Objekt erstellt, das den GPIO-Pin 4 abfragt. Die Funktion when_pressed registriert eine Callback-Funktion. Diese wird immer dann aufgerufen, wenn die Taste gedr\u00fcckt wird.<\/p>\n\n\n\n
    <\/div>\n\n\n\n
    Tastenprellen (Bouncing)<\/h2>\n\n\n\n
    Beim Einlesen von Tastern ist das sogenannte Tastenprellen (engl. \u201eBouncing“) ein unerw\u00fcnschtes, aber leider h\u00e4ufiges Ph\u00e4nomen, das bei mechanischen Schaltern auftritt. Wenn ein Taster gedr\u00fcckt wird, \u201eprellen“ die Kontaktelemente h\u00e4ufig voneinander ab, und es kann zu mehreren sehr schnellen Schaltvorg\u00e4ngen kommen, obwohl der Taster nur einmal bet\u00e4tigt wurde. Dies kann zu unerw\u00fcnschten Mehrfachausl\u00f6sungen f\u00fchren. Bild 2 <\/mark>zeigt diesen Prellvorgang auf einem Oszilloskop.<\/p>\n\n\n\n
    \"Bild
    Bild 2: Tastenprellen<\/figcaption><\/figure>\n\n\n\n
    <\/div>\n\n\n\n
    Wenn das obenstehende Programm l\u00e4uft, kann man h\u00e4ufig feststellen, dass die Ausgabe \u201eTaste gedr\u00fcckt!“ zwei- oder sogar mehrfach erfolgt, auch wenn die Taste nur einmal bet\u00e4tigt wurde. Dies ist nat\u00fcrlich im Allgemeinen unerw\u00fcnscht. GPIOZero hat bereits eine einfache L\u00f6sung f\u00fcr dieses Problem integriert: \u201eDebouncing“. Man kann den Debounce-Mechanismus einfach konfigurieren, indem man den bounce_time-Parameter setzt (Debounce.py).<\/p>\n\n\n\n
    from gpiozero import Button
    from signal import pause

    button = Button(4, bounce_time=0.1)

    def on_button_press():
        print(\"Taste gedr\u00fcckt, ohne Prellen!\")

    button.when_pressed = on_button_press
    pause()<\/code><\/pre>\n\n\n\n
    In diesem Beispiel wurde eine bounce_time=0.1 gew\u00e4hlt. Das bedeutet, dass GPIOZero nach dem ersten Tastendruck f\u00fcr 100 Millisekunden (= 0,1 s) keine weiteren Ereignisse registriert, was das Prellen effektiv unterdr\u00fcckt.<\/p>\n\n\n\n
    Die integrierte Unterst\u00fctzung f\u00fcr das Entprellen macht es also sehr einfach, zuverl\u00e4ssig und stabil Eingaben zu erfassen. Wenn mechanische Tasten verwendet werden, ist es immer eine gute Idee, das Prellen zu ber\u00fccksichtigen und den bounce_time-Parameter zu nutzen, um unerw\u00fcnschte Mehrfachausl\u00f6sungen zu vermeiden. Mit diesen Grundlagen kann man problemlos Taster einlesen und nur auf gew\u00fcnschte Eingabeereignisse reagieren.<\/p>\n\n\n\n
    Die Prellzeit (bounce time) eines Tasters h\u00e4ngt von den mechanischen Eigenschaften des Tasters ab. Preisg\u00fcnstige oder weniger pr\u00e4zise Taster neigen zu l\u00e4ngeren Prellzeiten, w\u00e4hrend qualitativ hochwertige Taster weniger stark prellen. Zudem weisen abgenutzte oder alte Taster, l\u00e4ngere Prellzeiten auf. Auch Umweltbedingungen wie Temperatur, Luftfeuchtigkeit oder Schmutz k\u00f6nnen die mechanische Funktionsweise eines Tasters beeinflussen und das Prellen verst\u00e4rken.<\/p>\n\n\n\n
    Typische Prellzeiten liegen zwischen 5 und 50 Millisekunden. Mit 100 ms liegt man also auf der sicheren Seite. \u00dcbertrieben lange Entprellzeiten f\u00fchren auch dazu, dass der Taster tr\u00e4ge reagiert. Sie sollten also vermieden werden. Um die Prellzeit zu optimieren, kann man folgenderma\u00dfen vorgehen:<\/p>\n\n\n\n
      \n
    • Man startet mit einer typischen Debounce-Zeit von 50 ms.<\/li>\n\n\n\n
    • Das Schaltverhalten wird beobachtet und die Prellzeit schrittweise reduziert, um eine schnellere Reaktionszeit des Tasters zu erzielen.<\/li>\n\n\n\n
    • Sobald der Taster Mehrfachausl\u00f6sungen produziert, muss die Zeit wieder erh\u00f6ht werden.<\/li>\n<\/ul>\n\n\n\n
      Wenn das Prellen besonders stark auftritt und Software-Debouncing nicht ausreicht, kann auch eine Hardware-Entprellung hinzuf\u00fcgt werden. Dies geschieht in der Regel durch das Einf\u00fcgen eines Kondensators parallel zum Taster oder das Verwenden eines Schmitt-Trigger-Schaltkreises.<\/p>\n\n\n\n
      <\/div>\n\n\n\n
      Schalten einer LED<\/h2>\n\n\n\n
      Viele moderne Ger\u00e4te wie Handys, Tablets oder PCs lassen sich mit einem Taster ein- und ausschalten. Diese Variante wird h\u00e4ufig bevorzugt, da klassische Schalter gr\u00f6\u00dfer, teurer und st\u00f6ranf\u00e4lliger sind. Zudem kann man bei der Taster-Variante eine automatische Abschaltfunktion vorsehen. Dies ist bei einem Schalter nicht m\u00f6glich, da Schalter immer manuell bet\u00e4tigt werden m\u00fcssen. In modernen elektronischen Ger\u00e4ten werden Schalter daher zunehmend durch Taster ersetzt. Das folgende Programm erlaubt es, eine LED mit einem Taster ein- und auszuschalten (Button_LED_Switcher.py):<\/p>\n\n\n\n
      from gpiozero import Button, LED\nfrom signal import pause\n\nled = LED(23)\nbutton = Button(4, bounce_time=0.1)\n\nled_status = False\n\ndef toggle_led():\n    global led_status\n    if led_status:\n        led.off()\n        print(\"LED ausgeschaltet\")\n    else:\n        led.on()\n        print(\"LED eingeschaltet\")\n    led_status = not led_status\n\nbutton.when_pressed = toggle_led\npause()<\/code><\/pre>\n\n\n\n
      \n
      \n
      Hier wird zun\u00e4chst ein LED-Objekt f\u00fcr den GPIO-Pin 23, an dem die LED angeschlossen ist, erstellt. Dann wird ein Button-Objekt f\u00fcr den GPIO-Pin 4, der mit dem Taster verbunden ist, erstellt inklusive einer Entprellzeit von 0,1 Sekunden. Die Funktion toggle_led() schaltet die LED um, wenn der Taster gedr\u00fcckt wird, d. h., wenn die LED an ist, wird sie ausgeschaltet und umgekehrt. Mit button.when_pressed wird die Funktion toggle_led() ausgef\u00fchrt, sobald der Taster gedr\u00fcckt wird. Die Funktion pause() h\u00e4lt das Programm am Laufen, damit es st\u00e4ndig auf ein Taster-Ereignis wartet. Mit diesem Code kann also eine LED mit einem Tastendruck ein- und ausgeschaltet werden (Bild 3)<\/mark>. Die GPIOZero-Bibliothek erm\u00f6glicht es dabei, mit minimalem Aufwand und \u00fcbersichtlichem Code die Aufgabe umzusetzen.<\/p>\n<\/div>\n\n\n\n
      \n
      \"Bild
      Bild 3: Raspberry Pi schaltet eine LED.<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
      <\/div>\n\n\n\n
      Taster zum Drehen: Rotary Encoder<\/h2>\n\n\n\n
      \n
      \n
      Ein Rotary Encoder oder Drehgeber misst die Drehbewegung seiner Achse und wandelt diese in elektrische Signale um. Er erm\u00f6glicht es, die Position, Geschwindigkeit oder Richtung einer Drehung zu erfassen. Insbesondere Inkremental-Encoder sind sehr preisg\u00fcnstig und weit verbreitet. Dieser Typ gibt bei jeder Drehbewegung Pulse aus. Die Anzahl der Pulse pro Umdrehung bestimmt die Genauigkeit. Die Drehrichtung kann durch zwei zeitversetzte Signale (A und B) bestimmt werden. Derartige Encoder werden in vielen Systemen verwendet, um pr\u00e4zise Steuerung oder Positionsfeedback zu bieten. Vor allem bei der Motorsteuerung, in der Robotik oder in Bedieneinheiten von z. B. CNC-Maschinen sind sie h\u00e4ufig zu finden. 

      Bild 4<\/mark> zeigt, wie man einen Rotary Encoder an den Raspberry Pi anschlie\u00dfen kann: Die Bedieneinheit MEXB-BP1 stellt einen passenden Encoder zur Verf\u00fcgung (s. Abschnitt Material), aber auch andere Inkrementalgeber k\u00f6nnen hier problemlos verwendet werden.<\/p>\n<\/div>\n\n\n\n
      \n
      \"Bild
      Bild 4: Rotary Encoder am Raspberry Pi<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
      <\/div>\n\n\n\n
      Dabei werden die folgenden Leitungen ben\u00f6tigt:<\/p>\n\n\n\n
      Encoder<\/th>Raspberry Pi<\/th><\/tr><\/thead>
      clk_pin (A)<\/td>17<\/td><\/tr>
      dt_pin (B)<\/td>18<\/td><\/tr>
      C<\/td>GND<\/td><\/tr>
      sw_pin<\/td>4 (optional)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
      Das zugeh\u00f6rige Programm sieht so aus (RotEnc.py):<\/p>\n\n\n\n
      from gpiozero import RotaryEncoder, Button\nfrom signal import pause\n\nclk_pin = 17  # CLK (A)\ndt_pin = 18   # DT (B)\nsw_pin = 4    # Optional: Button Pin\n\nencoder = RotaryEncoder(clk_pin, dt_pin, max_steps=100)\nbutton = Button(sw_pin, pull_up = True, bounce_time= None)\n\ndef turned():\n    print(f\"Position: {encoder.steps}\")\n\ndef button_pressed():\n    print(\"Button gedr\u00fcckt!\")\n\nencoder.when_rotated = turned\nbutton.when_pressed = button_pressed\npause()<\/code><\/pre>\n\n\n\n
      \n
      \n
      Die Ausgabe der relativen Position des Encoders erfolgt in die Shell (Bild 5)<\/mark>. Viele Encoder besitzen eine Zusatzfunktion: Beim Dr\u00fccken auf die Achse wird ein zus\u00e4tzlicher Schalter aktiviert. Diese Funktion ist im obigen Programm ebenfalls implementiert und kann bei Bedarf genutzt werden. Hierf\u00fcr muss zus\u00e4tzlich der Achsenschalter des Drehencoders mit Pin 4 des Raspberry Pi verbunden werden.<\/p>\n<\/div>\n\n\n\n
      \n
      \"Bild
      Bild 5: Rotary-Encoder-Positionsdaten<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
      Im letzten Beitrag dieser Serie wurde die MatPlotLib-Bibliothek ausf\u00fchrlich dargestellt. In Kombination mit dem Rotary Encoder k\u00f6nnen nun die Eingangsdaten des Bauelements grafisch dargestellt werden.
      Das folgende Programm (RotEnc_to_MatPlotLib.py) liefert die Grundlage dazu:<\/p>\n\n\n\n
      from gpiozero import RotaryEncoder, Button
      import matplotlib.pyplot as plt
      from matplotlib.animation import FuncAnimation
      import time

      clk_pin = 17  # CLK (A)
      dt_pin = 18   # DT (B)

      encoder = RotaryEncoder(clk_pin, dt_pin, max_steps=100)
      button = Button(sw_pin, pull_up = True, bounce_time= None)

      positions = []
      times = []

      start_time = time.time()

      def update_plot(frame):
          current_time = time.time() - start_time
          current_position = encoder.steps

          positions.append(current_position)
          times.append(current_time)

          ax.clear()
          ax.plot(times, positions, label='Encoder Position')
          ax.set_xlabel('Zeit (s)')
          ax.set_ylabel('Position (Schritte)')
          ax.legend()

      fig, ax = plt.subplots()
      ani = FuncAnimation(fig, update_plot, interval=100)
      plt.show()<\/code><\/pre>\n\n\n\n
      <\/p>\n\n\n\n
      Das Programm erfasst die Drehposition eines Rotary Encoders in Echtzeit und stellt diese grafisch dar. Der RotaryEncoder wird mit den Pins (17 und 18) und einer maximalen Schrittzahl von 100 initialisiert. Danach werden zwei Listen, positions und times, erstellt, um die Position des Encoders und die dazugeh\u00f6rige Zeit zu speichern. Die Zeitmessung beginnt mit start_time, um die Zeitdifferenz w\u00e4hrend der Laufzeit zu berechnen.  
      Die Funktion update_plot wird in regelm\u00e4\u00dfigen Abst\u00e4nden (alle 100 Millisekunden) von FuncAnimation aufgerufen. <\/p>\n\n\n\n
      \n
      \n
      Diese Funktion liest die aktuelle Position des Encoders (encoder.steps) und berechnet die verstrichene Zeit seit start_time. Zudem aktualisiert sie das Diagramm, das so die Position des Encoders \u00fcber die Zeit darstellt. Via MatPlotLib wird damit eine Echtzeit-Grafik angezeigt, in der auf der x-Achse die Zeit in Sekunden und auf der y-Achse die Encoder-Position (in Schritten) dargestellt ist. Die Grafik wird kontinuierlich aktualisiert, w\u00e4hrend der Rotary Encoder gedreht wird. Das Programm zeigt somit die Position des Rotary Encoders in Echtzeit als Funktion der Zeit in einem animierten Diagramm an (Bild 6)<\/mark>.<\/p>\n<\/div>\n\n\n\n
      \n
      \"Bild
      Bild 6: Grafische Darstellung der Rotary-Encoder-Positionsdaten<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
      <\/div>\n\n\n\n
      Digitaler LED-Dimmer<\/h2>\n\n\n\n
      Bei einem klassischen LED-Dimmer kommt meist ein Potentiometer zusammen mit einem stromverst\u00e4rkenden Transistor zum Einsatz. Diese Variante hat den Nachteil, dass man die Aufl\u00f6sung nicht einstellen kann, da sie sich aus dem Drehbereich des Potentiometers ergibt. Bei einer modernen Variante eines LED-Dimmers mithilfe eines Rotary Encoders kann man dagegen die Aufl\u00f6sung und die Schrittweite der LED-Helligkeit sehr flexibel w\u00e4hlen.<\/p>\n\n\n\n
      Das folgende Programm (RotEnc_to_LED.py) zeigt, wie man die Helligkeit einer LED \u00fcber einen Rotary Encoder ver\u00e4ndern kann.<\/p>\n\n\n\n
      from gpiozero import RotaryEncoder, PWMLED\nfrom signal import pause\n\nclk_pin = 17  # CLK (A)\ndt_pin = 18   # DT (B)\nled_pin = 23  # PWM-f\u00e4higer Pin f\u00fcr die LED\n\nencoder = RotaryEncoder(clk_pin, dt_pin, max_steps=10) # 100 Schritte insgesamt\nled = PWMLED(led_pin)\n\ndef update_led_brightness():\n    brightness = max(0, min(1, encoder.steps \/ 10)) # Begrenzung auf Werte zwischen 0 und 1\n    led.value = brightness\n    print(f\"Helligkeit: {brightness * 100:.0f}%\")\n\nencoder.when_rotated = update_led_brightness\n\nprint(\"Drehen Sie den Rotary Encoder, um die LED-Helligkeit anzupassen.\")\npause()<\/code><\/pre>\n\n\n\n
      Der Rotary Encoder wird \u00fcber die GPIO-Pins 17 (A: CLK) und 18 (B: DT) abgefragt. Mit max_steps=100 wird der Encoder auf 100 Schritte begrenzt. Die LED ist an einem PWM-f\u00e4higen Pin (GPIO 23) angeschlossen, sodass ihre Helligkeit zwischen 0 und 100 % stufenlos ver\u00e4ndert werden kann. Die Funktion update_led_brightness wird immer dann aufgerufen, wenn der Rotary Encoder gedreht wird. Sie berechnet die Helligkeit der LED, basierend auf der aktuellen Position des Encoders (zwischen 0 und 100 Schritten). Der Wert f\u00fcr die LED wird als PWM-Wert (zwischen 0 und 1) an die LED weitergegeben, um die Helligkeit anzupassen.
      pause():<\/mark><\/code> H\u00e4lt das Programm wieder im Hintergrund am Laufen, sodass es jederzeit auf Ereignisse vom Rotary Encoder reagieren kann.
      Zur Kontrolle wird der aktuelle Helligkeitslevel zus\u00e4tzlich in der Shell ausgegeben. Auf der Hardwareseite muss die Schaltung nach Bild 3 <\/mark>lediglich um eine LED (mit Vorwiderstand) an Pin 23 erg\u00e4nzt werden. Nach dem Starten des Programms kann deren Helligkeit dann mit dem Rotary Encoder ver\u00e4ndert werden. Im Abschnitt \u201eErg\u00e4nzungen und \u00dcbungen\u201c finden sich einige Anregungen, wie man das Programm an verschiedene Anforderungen anpassen kann.<\/p>\n\n\n\n
      <\/div>\n\n\n\n
      Matrix-Tastaturen<\/h2>\n\n\n\n
      Matrix-Tastaturen sind n\u00fctzlich, wenn mehrere Eingabetasten ben\u00f6tigt werden. Sie bestehen aus einer Anordnung von Tasten, die in Zeilen und Spalten organisiert sind. Eine 4×4-Matrix-Tastatur zum Beispiel bietet 16 Tasten, die sich \u00fcber vier Zeilen und vier Spalten verteilen. Eine Matrix-Tastatur verwendet ein spezielles Netzwerk, um die Tasten miteinander zu verbinden. Jede Taste schlie\u00dft einen anderen Strompfad zwischen einer Zeile und einer Spalte. Dies erm\u00f6glicht es dem Raspberry Pi zu erkennen, welche Taste gedr\u00fcckt wurde, ohne f\u00fcr jede Taste einen eigenen GPIO-Pin zu ben\u00f6tigen.<\/p>\n\n\n\n
      Wird beispielsweise eine 4×4-Matrix verwendet, br\u00e4uchte man bei einer direkten Verschaltung der Tasten 17 Leitungen (eine f\u00fcr jede Taste plus eine Ground-Leitung). Bei einer Matrix-Verschaltung hingegen werden nur acht Leitungen (vier Zeilen und vier Spalten) ben\u00f6tigt.
      Zum Auslesen der Matrix werden spezielle Bibliotheken verwendet, um die Tastendr\u00fccke zu dekodieren und auf die gedr\u00fcckten Tasten zu reagieren. Um eine Matrix-Tastatur an den Raspberry Pi anzuschlie\u00dfen, sind also mehrere GPIO-Pins erforderlich, je nachdem wie viele Zeilen und Spalten die Tastatur hat. Mit Python-Bibliotheken k\u00f6nnen Tastendr\u00fccke einfach ausgelesen und verarbeitet werden.<\/p>\n\n\n\n
      \n
      \n
      Bild 7 <\/mark>zeigt Matrix-Tastaturen in mehreren Varianten. Diese Tastaturen haben gemeinsam, dass sie jeweils 16 bzw. zw\u00f6lf Tasten und acht bzw. sieben Anschlussleitungen besitzen. Sie k\u00f6nnen z. B. gem\u00e4\u00df der folgenden Tabelle an die GPIO-Pins eines Raspberry Pi angeschlossen werden.

      Zeilenleitungen – 10-Pins: 17, 27, 22, 5
      Spaltenleitungen – 10-Pins: 6, 13, 19, 26<\/p>\n<\/div>\n\n\n\n
      \n
      \"Bild
      Bild 7: Matrix-Tastaturen<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
      \n
      \n
      Bei der 12-Tasten-Matrix kann eine Spaltenleitung entfallen. Bild 8<\/mark> zeigt eine Aufbauvorschlag f\u00fcr den Anschluss der Folientastatur.<\/p>\n<\/div>\n\n\n\n
      \n
      \"Bild
      Bild 8: Folientastatur am Raspberry Pi<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
      Um die Tastatur auszulesen, kann das folgende Beispielprogramm (KeyMatrix.py) verwendet werden. Es nutzt die Bibliothek gpiozero und gibt die jeweils gedr\u00fcckte Taste auf der Konsole aus.<\/p>\n\n\n\n
      from gpiozero import DigitalOutputDevice, Button
      from time import sleep

      # GPIO-Pins f\u00fcr die Zeilen und Spalten definieren
      rows = [17, 27, 22, 5]
      columns = [6, 13, 19, 26]

      key_map = [
          ['1', '2', '3', 'A'],
          ['4', '5', '6', 'B'],
          ['7', '8', '9', 'C'],
          ['*', '0', '#', 'D']
      ]

      row_pins = [DigitalOutputDevice(pin) for pin in rows]
      col_pins = [Button(pin, pull_up=False) for pin in columns]

      def scan_matrix():
          for row_num, row_pin in enumerate(row_pins):
              row_pin.on() # Aktiviere die aktuelle Zeile
              for col_num, col_pin in enumerate(col_pins):
                  if col_pin.is_pressed:
                      print(f\"Taste {key_map[row_num][col_num]} gedr\u00fcckt\")
              row_pin.off() # Deaktiviere die aktuelle Zeile
          sleep(0.1)

      try:
          while True:
              scan_matrix()
              sleep(0.1) # kurze Pause zwischen den Scans
      except KeyboardInterrupt:
          print(\"Programm beendet.\")<\/code><\/pre>\n\n\n\n
      Nach dem Import der Bibliotheken gpiozero uind time import erfolgt die Definition der GPIO-Pins:<\/p>\n\n\n\n
      rows = [17, 27, 22, 5]<\/code><\/pre>\n\n\n\n
      Die GPIO-Pins f\u00fcr die Zeilen (oben) sind je nach Verkabelung anpassbar, ebenso die GPIO-Pins f\u00fcr die Spalte:<\/p>\n\n\n\n
      columns = [6, 13, 19, 26]<\/code><\/pre>\n\n\n\n
      Die Definition der Tastenbelegung erfolgt in einem Array:<\/p>\n\n\n\n
      key_map = [
          ['1', '2', '3', 'A'],
          ['4', '5', '6', 'B'],
          ['7', '8', '9', 'C'],
          ['*', '0', '#', 'D']
      ]<\/code><\/pre>\n\n\n\n
      Diese sogenannte key_map besteht aus einem 4×4-Array, das die Zuordnung der Tasten in der Matrix definiert. Jede Taste hat eine spezifische Position in der Matrix. Zum Beispiel befindet sich die Taste ‚1‘ in der ersten Zeile und ersten Spalte, w\u00e4hrend sich ‚D‘ in der vierten Zeile und vierten Spalte befindet. Nat\u00fcrlich k\u00f6nnen hier, je nach Tastenbeschriftung auch andere Werte gew\u00e4hlt werden. Es folgt die Initialisierung der GPIO-Pins:<\/p>\n\n\n\n
      row_pins = [DigitalOutputDevice(pin) for pin in rows]\ncol_pins = [Button(pin, pull_up=False) for pin in columns]<\/code><\/pre>\n\n\n\n
        \n
      • Die Zeilen-Pins werden als DigitalOutputDevice-Objekte initialisiert, sodass sie als digitale Ausg\u00e4nge verwendet werden k\u00f6nnen. Sie steuern die Stromversorgung der Zeilen der Tastenmatrix.<\/li>\n\n\n\n
      • Die Spalten-Pins werden dagegen als Button-Objekte initialisiert, die als Eing\u00e4nge fungieren. Der Parameter pull_up=False bedeutet, dass kein interner Pull-up-Widerstand verwendet wird (dieser ist normalerweise nur bei Einzeltasten n\u00fctzlich).<\/li>\n<\/ul>\n\n\n\n
        Die Funktion scan_matrix() dient zur \u00dcberpr\u00fcfung der Tastenmatrix. Diese Funktion durchl\u00e4uft die Zeilen der Matrix, aktiviert jeweils eine Zeile und \u00fcberpr\u00fcft, ob eine Taste in einer der Spalten gedr\u00fcckt wurde.<\/p>\n\n\n\n
          \n
        • row_pin.on(): Aktiviert die Stromversorgung f\u00fcr die aktuelle Zeile.<\/li>\n\n\n\n
        • col_pin.is_pressed: \u00dcberpr\u00fcft, ob die Taste in der aktuellen Spalte gedr\u00fcckt wurde. Wenn ja, wird die entsprechende Taste aus der key_map ausgegeben.<\/li>\n\n\n\n
        • row_pin.off(): Deaktiviert die Zeile, bevor zur n\u00e4chsten Zeile \u00fcbergegangen wird.<\/li>\n\n\n\n
        • Die Endlosschleife ruft die scan_matrix()-Funktion auf, um kontinuierlich auf Tastendr\u00fccke zu pr\u00fcfen. Die Funktion sleep(0.1) sorgt f\u00fcr eine kurze Pause zwischen den Scans, um den Raspberry Pi nicht zu \u00fcberlasten und eine zu schnelle Abfrage zu vermeiden. Falls das Programm mit \u201eStrg + C“ beendet wird, gibt es eine entsprechende Ausgabe (\u201eProgramm beendet“) aus.<\/li>\n<\/ul>\n\n\n\n
          \n
          \n
          Bild 9 <\/mark>zeigt die Ausgabe auf der Shell, nachdem die Tasten 1, 2, 3, und A, B, C auf der Matrix-Tastatur gedr\u00fcckt wurden.<\/p>\n<\/div>\n\n\n\n
          \n
          \"Bild
          Bild 9: Testausgabe der Folientastatur am Raspberry Pi<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
          <\/div>\n\n\n\n
          \n
          Erg\u00e4nzungen und \u00dcbungen<\/h2>\n\n\n\n
            \n
          • Bestimmen Sie die optimale Prellzeit zum Schalten einer LED mit einem bestimmten Tastertyp.<\/li>\n\n\n\n
          • Anpassungsm\u00f6glichkeiten f\u00fcr die LED-Helligkeitssteuerung: Pinbelegung: \u00c4ndern Sie die clk_pin, dt_pin und led_pin je nach Hardware-Setup. Maximale Schritte: Passen Sie max_steps so an, dass die LED sehr feinf\u00fchlig gesteuert werden kann.<\/li>\n\n\n\n
          • Welche M\u00f6glichkeiten gibt es, eine falsche Zuordnung der Tasten bei einer Folientastatur zu korrigieren (Hardware, Software)?<\/li>\n<\/ul>\n<\/div>\n\n\n\n
            <\/div>\n\n\n\n
            Ausblick<\/h2>\n\n\n\n
            In diesem Artikel wurde bereits die Technik der Pulsweitenmodulation (PWM) zur Ansteuerung der Helligkeit einer LED verwendet. Im n\u00e4chsten Beitrag soll dieses h\u00e4ufig eingesetzte Verfahren genauer betrachtet werden. Zudem sollen sogenannte Digital-Analog-Converter zum Einsatz kommen. Diese Technologien gestatten es, analoge Spannungen auszugeben und so z. B. die Helligkeit von LEDs zu ver\u00e4ndern. Es lassen sich aber nicht nur LEDs steuern, sondern z. B. auch die Geschwindigkeit von Motoren. So k\u00f6nnen z. B. Roboter oder L\u00fcfter sehr pr\u00e4zise angesteuert werden.<\/p>\n\n\n\n
            <\/div>\n\n\n\n
            Material<\/h2>\n\n\n\n
              \n
            • Raspberry Pi mit Netzteil<\/li>\n\n\n\n
            • Kleinteile (LEDs, Taster etc.) finden sich z. B. im PAD-PRO-EXSB Professional Set<\/li>\n\n\n\n
            • Folientastatur oder selbst aufgebaute Tastenmatrix<\/li>\n<\/ul>\n\n\n
              \n    
              <\/div>\n<\/div>\n\n\n\n
              <\/div>\n\n\n\n
              \u00dcber den Autor
              <\/strong>Dr. G\u00fcnter Spanner ist als Autor zu den Themen Elektronik, Sensortechnik und Mikrocontroller einem weiten Fachpublikum bekannt. Schwerpunkt seiner hauptberuflichen T\u00e4tigkeit f\u00fcr verschiedene Gro\u00dfkonzerne wie Siemens und ABB ist die Projektleitung im Bereich Entwicklung und Technologie-Management. Der Dozent fu\u0308r Physik und Elektrotechnik hat zudem zahlreiche Fachartikel und Bu\u0308cher vero\u0308ffentlicht sowie Kurse und Lernpakete erstellt.<\/p>\n","protected":false},"excerpt":{"rendered":"
              Dateneingabe am Raspberry Pi leicht gemacht: Lernen Sie, wie Taster zuverl\u00e4ssig entprellt, Rotary Encoder f\u00fcr Position & Helligkeit genutzt und 4\u00d74-Matrix-Tastaturen mit Python\/GPIOZero ausgelesen werden. Inklusive Codebeispielen, LED-Dimmer, Plot-Visualisierung und Tipps f\u00fcr robuste Hardware-Setups.<\/p>\n","protected":false},"author":30,"featured_media":864,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[34],"tags":[660,655,653,657,661,654,658,656,659],"post-author":[137],"class_list":["post-3638","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python-micropython","tag-debouncing","tag-gpiozero","tag-matrix-tastatur","tag-pwm-led-dimmer","tag-python-beispielcode","tag-raspberry-pi-gpio","tag-rotary-encoder","tag-rpi-gpio","tag-taster-entprellen","post-author-dr-guenter-spanner"],"acf":[],"info":{"thumbnail":{"url":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/header_phyton_teil11.jpg","alt":""},"teaserImage":{"ID":3694,"id":3694,"title":"liste-beitrag_python_t7","filename":"Liste-Beitrag_python_t7.jpg","filesize":57370,"url":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t7.jpg","link":"https:\/\/de.elv.com\/elvjournal\/raspberry-pi-gpio-eingaben-taster-encoder-matrix\/liste-beitrag_python_t7\/","alt":"","author":"5","description":"","caption":"","name":"liste-beitrag_python_t7","status":"inherit","uploaded_to":3638,"date":"2025-09-11 16:21:48","modified":"2025-09-11 16:21:48","menu_order":0,"mime_type":"image\/jpeg","type":"image","subtype":"jpeg","icon":"https:\/\/elvjournal.elv.com\/wp-includes\/images\/media\/default.png","width":312,"height":198,"sizes":{"thumbnail":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t7-250x198.jpg","thumbnail-width":250,"thumbnail-height":198,"medium":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t7-300x190.jpg","medium-width":300,"medium-height":190,"medium_large":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t7.jpg","medium_large-width":312,"medium_large-height":198,"large":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t7.jpg","large-width":312,"large-height":198,"1536x1536":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t7.jpg","1536x1536-width":312,"1536x1536-height":198,"2048x2048":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t7.jpg","2048x2048-width":312,"2048x2048-height":198,"gform-image-choice-sm":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t7.jpg","gform-image-choice-sm-width":300,"gform-image-choice-sm-height":190,"gform-image-choice-md":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t7.jpg","gform-image-choice-md-width":312,"gform-image-choice-md-height":198,"gform-image-choice-lg":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t7.jpg","gform-image-choice-lg-width":312,"gform-image-choice-lg-height":198}},"categories":[{"id":34,"name":"Python & MicroPython","slug":"python-micropython"}],"authors":[{"id":137,"name":"Dr. G\u00fcnter Spanner","slug":"dr-guenter-spanner"}],"document":false,"epaper":"","date":"25. Februar 2026","excerpt":"Dateneingabe am Raspberry Pi leicht gemacht: Lernen Sie, wie Taster zuverl\u00e4ssig entprellt, Rotary Encoder f\u00fcr Position & Helligkeit genutzt und 4\u00d74-Matrix-Tastaturen mit Python\/GPIOZero ausgelesen werden. Inklusive Codebeispielen, LED-Dimmer, Plot-Visualisierung und Tipps f\u00fcr robuste Hardware-Setups."},"_links":{"self":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/3638","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/users\/30"}],"replies":[{"embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/comments?post=3638"}],"version-history":[{"count":10,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/3638\/revisions"}],"predecessor-version":[{"id":14194,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/3638\/revisions\/14194"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/media\/864"}],"wp:attachment":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/media?parent=3638"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/categories?post=3638"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/tags?post=3638"},{"taxonomy":"post-author","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/post-author?post=3638"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}