{"id":4342,"date":"2026-02-19T08:50:15","date_gmt":"2026-02-19T07:50:15","guid":{"rendered":"https:\/\/staging.elv.eqxt.de\/?p=4342"},"modified":"2026-03-04T17:02:27","modified_gmt":"2026-03-04T16:02:27","slug":"python-einstieg-raspberry-pi-teil1","status":"publish","type":"post","link":"https:\/\/de.elv.com\/elvjournal\/python-einstieg-raspberry-pi-teil1\/","title":{"rendered":"Einstieg in Python (Teil 1): Erste Schritte zur Hardwaresteuerung"},"content":{"rendered":"\n

Einstieg in Python, Teil 1<\/strong><\/p>\n\n\n\n

Erste Schritte zur Hardwaresteuerung<\/h1>\n\n\n\n

Mit diesem Beitrag soll eine Einf\u00fchrung in die universelle und moderne Programmiersprache \u201ePython“ gestartet werden. Der Fokus wird dabei auf der Hardwaresteuerung und hardwarenahen Programmierung liegen. Die Gr\u00fcnde, warum Python als Programmiersprache immer beliebter wird, sind vielf\u00e4ltig. Einer der wichtigsten Punkte ist sicher die einfache Erlernbarkeit der Sprache. Zudem verf\u00fcgt Python \u00fcber eine klare und einfache Syntax, die leicht zu erfassen und auch gut in Projekten umzusetzen ist.<\/strong><\/p>\n\n\n\n

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

Python: kompakt und universell einsetzbar<\/h2>\n\n\n\n

In Python sind meist deutlich weniger Codezeilen im Vergleich zu anderen Programmiersprachen erforderlich. Dadurch wird die Verst\u00e4ndlichkeit verbessert und die Entwicklung von Anwendungen beschleunigt. Zudem kann Python f\u00fcr die verschiedensten Applikationen eingesetzt werden, von der Datenanalyse bis hin zu K\u00fcnstlicher Intelligenz, von Hausautomatisierung bis hin zur komplexen Hardwaresteuerung. Die Sprache bietet eine breite Palette von Bibliotheken und Frameworks, welche die Entwicklung erleichtern.<\/p>\n\n\n\n

Dar\u00fcber hinaus bietet Python eine aktive Entwickler-Community, die kontinuierlich neue Module, Pakete und Tools erstellt. Es gibt eine F\u00fclle von Ressourcen, Tutorials und Dokumentationen, die dabei helfen, Programmierkenntnisse aufzubauen und zu erweitern. Diese Gr\u00fcnde machen Python zu einer attraktiven Option f\u00fcr Anf\u00e4nger und erfahrene Entwickler gleicherma\u00dfen. Es ist eine vielseitige Sprache, die f\u00fcr eine Vielzahl von Anwendungen geeignet ist und eine starke Unterst\u00fctzung in der \u201eCommunity“ genie\u00dft.<\/p>\n\n\n\n

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

\u00dcberblick und verwendete Programmstrukturen<\/h2>\n\n\n\n

Neben einer grundlegenden Einf\u00fchrung werden in diesem Beitrag die folgenden Programmstrukturen vorgestellt:<\/p>\n\n\n\n

    \n
  • Importieren von Bibliotheken<\/li>\n\n\n\n
  • Zeitsteuerung mit sleep<\/li>\n\n\n\n
  • Hardware Steuerung mit\n
      \n
    • setmode<\/li>\n\n\n\n
    • setup<\/li>\n\n\n\n
    • output<\/li>\n<\/ul>\n<\/li>\n\n\n\n
    • \u201etry\/except\u201c-Konstruktion<\/li>\n<\/ul>\n\n\n\n
      <\/div>\n\n\n\n

      Voraussetzungen und Hardwaregrundlagen<\/h2>\n\n\n\n

      Um die Praxisbeispiele des Kurses erfolgreich umsetzen zu k\u00f6nnen, sollten die folgenden Voraussetzungen erf\u00fcllt sein:<\/p>\n\n\n\n

        \n
      • Sicherer Umgang mit dem Betriebssystem Windows<\/li>\n\n\n\n
      • Grundlegendes Wissen zum Themenkreis \u201eElektronik“, insbesondere im Bereich \u201eStrom – Spannung – Widerstand“<\/li>\n\n\n\n
      • Elementare Kenntnisse einer beliebigen Programmiersprache wie Basic oder C<\/li>\n<\/ul>\n\n\n\n

        Der Fokus wird auf Hardwaresteuerung und Praxisanwendungen liegen. Typische Programmstrukturen wie \u201eIf“, \u201eWhile“ etc. sollten daher vom Prinzip her bekannt sein. Bei Bedarf k\u00f6nnen diese Informationen nachgelesen werden (G. Spanner, MicroPython, Elektor Verlag (2020)). Grundkenntnisse im Umgang mit Linux sind vorteilhaft, aber nicht unbedingt erforderlich, da notwendige Befehle bei den entsprechenden Anwendungen erl\u00e4utert werden.<\/p>\n\n\n\n

        Die Hardware-Aufbauten sind bewusst einfach gehalten, damit sie ohne Probleme auf Laborsteckboards (Breadboards) aufgebaut werden k\u00f6nnen. Damit auch Einsteiger alle Praxisanwendungen funktionssicher nachbauen k\u00f6nnen, sollen so weit wie m\u00f6glich Komponenten aus den sogenannten Prototypen-Adapter-Sets (PADs) zum Einsatz kommen. Diese bieten aufgrund ihrer Beschriftung, ihrer hervorragenden elektrischen Eigenschaften und ihres kompakten Aufbaus eine hervorragende Grundlage f\u00fcr die technische Seite des Programmierkurses.<\/p>\n\n\n\n

        \n
        \n

        Bild 1 <\/mark>zeigt einige relevante Komponenten aus dieser Serie. Welche Bauelemente bzw. PAD-Version im einzelnen erforderlich sind, wird bei den entsprechenden Anwendungsbeispielen angegeben.<\/p>\n\n\n\n

        Dar\u00fcber hinaus erforderlich sind:<\/p>\n\n\n\n

          \n
        • ein PC oder Laptop mit USB-Schnittstelle<\/li>\n\n\n\n
        • das Betriebssystem Windows 10<\/li>\n\n\n\n
        • ein Internetzugang<\/li>\n<\/ul>\n<\/div>\n\n\n\n
          \n
          \"Komponenten
          Bild 1: Einige Komponenten f\u00fcr den praktischen Einsatz unter Python<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n

          Raspberry Pi und Pico als Python-Controller<\/h2>\n\n\n\n

          Alle Programmieraufgaben sollen auf einem Raspberry Pi umgesetzt werden. In sp\u00e4teren Anwendungen wird dann auch ein Raspberry Pi Pico zum Einsatz kommen. Der Pi ist f\u00fcr diese Aufgaben besonders geeignet, da Python die bevorzugte Sprache dieses Boards ist. Alle erforderlichen Softwarekomponenten stehen daher standardm\u00e4\u00dfig zur Verf\u00fcgung. Zudem weist der Pi eine Reihe von elektrischen Ein- und Ausg\u00e4ngen (I\/O-Ports) auf, die den direkten Anschluss elektronischer Komponenten erm\u00f6glichen.<\/p>\n\n\n\n

          Ausf\u00fchrliche Informationen zum Raspberry Pi bzw. zum Pico finden sich z. B. hier: G. Spanner, Raspberry Pi 4 und Pico \u2212 Pfiffige Projekte zum Messen, Steuern und Regeln, Elektor Verlag (2023).<\/p>\n\n\n\n

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

          Thonny als Programmierumgebung<\/h2>\n\n\n\n

          Die Thonny Python IDE (Integrated Development Environment) ist der Standard-Editor zum Programmieren mit Python auf dem Raspberry Pi. Die IDE ist im Raspberry Pi OS bestens integriert und bietet viele Vorteile:<\/p>\n\n\n\n

            \n
          • Der integrierte Text-Editor unterst\u00fctzt Syntax-Highlighting f\u00fcr Python und MicroPython.<\/li>\n\n\n\n
          • F\u00fcr das Datei-Management existiert eine eigene Ansicht. Funktionen wie Speichern und L\u00f6schen von Dateien k\u00f6nnen direkt in der IDE ausgef\u00fchrt werden.<\/li>\n\n\n\n
          • F\u00fcr die Text-Eingabe und -Ausgabe existiert die Ansicht einer Kommandozeile\/Konsole\/Shell.<\/li>\n\n\n\n
          • Externe Bibliotheken k\u00f6nnen \u00fcber einen integrierten Paket-Manager installiert werden.<\/li>\n\n\n\n
          • Wird ein neuer Raspberry Pi Pico ohne MicroPython-Firmware erkannt, wird die Installation automatisch angeboten etc.<\/li>\n<\/ul>\n\n\n\n

            Bild 2 <\/mark>zeigt die Thonny IDE nach dem Start. <\/p>\n\n\n\n

            \"Starten
            Bild 2: Starten der Python IDE Thonny<\/figcaption><\/figure>\n\n\n\n
            <\/div>\n\n\n\n

            F\u00fcr die Arbeit mit Thonny stehen verschiedene Funktionen zur Verf\u00fcgung. Die Nummern in den roten Kreisen in Bild 3 <\/mark>zeigen die Funktionseinheiten der IDE:<\/p>\n\n\n\n

              \n
            1. Die Men\u00fcleiste enth\u00e4lt wichtige Funktionen zur Dateiverwaltung und zum Starten und Stoppen des aktuell sichtbaren Programmcodes.<\/li>\n\n\n\n
            2. Das Textfeld f\u00fcr den Quelltext bzw. Programmcode ist ein Text-Editor mit Syntax-Highlighting.<\/li>\n\n\n\n
            3. Eingabe- und Ausgabefeld f\u00fcr Text-Informationen w\u00e4hrend des Programmablaufs, das man als Kommandozeile, Konsole, Shell oder Eingabeaufforderung bezeichnet<\/li>\n\n\n\n
            4. \u00dcbersicht zum aktiven Dateiordner<\/li>\n<\/ol>\n\n\n\n

              Durch ihren einfachen Aufbau und die klare Struktur wurde die Thonny IDE zum Quasi-Standard f\u00fcr die Python-Programmierung. Deshalb soll sie auch im Rahmen dieser Artikelserie zum Einsatz kommen.<\/p>\n\n\n\n

              \"Funktionen
              Bild 3: Die Funktionen der Thonny IDE<\/figcaption><\/figure>\n\n\n\n
              <\/div>\n\n\n\n

              Experimentiersysteme<\/h2>\n\n\n\n

              F\u00fcr die praktische Umsetzung der Hardwarebeispiele bietet sich der Einsatz von hochwertigen Breadboards an. Dieses System eignet sich bestens zum Aufbau der erforderlichen Schaltungen. Bild 4<\/mark> zeigt exemplarisch einen typischen Aufbau mit einer LED aus dem Set von PAD6 als High-\/Low-Indikator (CMOS-Logik).<\/p>\n\n\n\n

              \"Aufbau
              Bild 4: Aufbau mit Raspberry Pi und Breadboard-Schaltung<\/figcaption><\/figure>\n\n\n\n
              <\/div>\n\n\n\n

              Die einfache Kombination aus Raspberry Pi und Breadboard-Aufbauten ist f\u00fcr viele Praxisanwendungen bereits ausreichend. Allerdings weist diese Variante einige Nachteile auf. Sie ist mechanisch nicht optimal, wenn der Aufbau z. B. einmal bewegt werden muss. Zudem stehen keine Bedienelemente wie Schalter, Taster oder Potentiometer etc. direkt zur Verf\u00fcgung.<\/p>\n\n\n\n

              Ein komplettes Experimentiersystem wie das EXSB1<\/span> l\u00f6st diese Probleme. Wird zudem der Raspberry Pi mit einigen mechanischen Elementen oben an diesem System fixiert, steht ein nahezu ideales Aufbausystem zur Verf\u00fcgung, mit dem die elektronische Seite des Python-Kurses zum reinen Vergn\u00fcgen wird.<\/p>\n\n\n\n

              Bild 5<\/mark> zeigt einen entsprechenden Aufbauvorschlag. Nat\u00fcrlich k\u00f6nnen f\u00fcr die Befestigung des Raspberry Pi auch andere Varianten zum Einsatz kommen. In Bild 5 <\/mark>ist zus\u00e4tzlich noch ein Mini-Voltmeter-Modul<\/span> zu sehen. Dieses ist f\u00fcr die ersten Experimente nicht unbedingt erforderlich, es kann allerdings f\u00fcr viele Anwendungen vorteilhaft eingesetzt werden (siehe Abschnitt \u201eMini-Voltmeter als Logic-Analyzer“).<\/p>\n\n\n\n

              \"Raspberry
              Bild 5: Raspberry Pi am EXSB1-Experimentierboard<\/figcaption><\/figure>\n\n\n\n
              <\/div>\n\n\n\n

              LEDs und Logik-Level-Anzeige im Einsatz<\/h2>\n\n\n\n
              \n
              \n

              In einem ersten Praxisbeispiel sollen die Funktion der I\/O-Ports des Raspberry Pi \u00fcberpr\u00fcft und erprobt werden. Wenn das EXSB1-System zur Verf\u00fcgung steht, kann dazu eine der auf dem Board vorhandenen LEDs verwendet werden. Dies hat den Vorteil, dass der erforderliche Vorwiderstand ebenfalls bereits vorhanden ist. Bild 6<\/mark> zeigt den entsprechenden Aufbau dazu.<\/p>\n<\/div>\n\n\n\n

              \n
              \"Hardware-Aufbau
              Bild 6: Hardware-Aufbau zur Ansteuerung einer LED mit Python<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
              \n
              \n

              Falls die Schaltung auf einem einzelnen Breadboard aufgebaut werden soll, ist zu beachten, dass die LED mit einem strombegrenzenden Widerstand zwischen mindestens 150\u03a9 bis 1k\u03a9 gesch\u00fctzt werden muss. Alternativ k\u00f6nnen auch LED-Module aus den PAD-Adaptersets verwendet werden. Diese verf\u00fcgen \u00fcber einen bereits integrierten Vorwiderstand auf der Platine. Zur Verdeutlichung zeigt Bild 7<\/mark> den Aufbau nochmals als realit\u00e4tsnahes Schaltbild.<\/p>\n<\/div>\n\n\n\n

              \n
              \"LED-Steuerung
              Bild 7: LED-Steuerung als realit\u00e4tsnahes\nSchaltbild<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
              <\/div>\n\n\n\n

              Ein erstes Python-Programm<\/h2>\n\n\n\n

              Das folgende Python-Programm sorgt daf\u00fcr, dass die LED im Sekundentakt blinkt (blink_LED_1_Hz.py):<\/p>\n\n\n\n

              import RPi.GPIO as GPIO\nimport time\n\nled_pin = 18\nGPIO.setmode(GPIO.BCM)\nGPIO.setup(led_pin, GPIO.OUT)\n\nwhile True:\n    GPIO.output(led_pin, GPIO.HIGH)\n    time.sleep(0.5)\n    GPIO.output(led_pin, GPIO.LOW)\n    time.sleep(0.5)<\/code><\/pre>\n\n\n\n
              <\/div>\n\n\n\n
              \n
              \n
              Alle Programme und Skripts etc. sind im Downloadpaket zu diesem Artikel enthalten. Das Programm kann also entweder (zu \u00dcbungszwecken) abgetippt werden oder man l\u00e4dt es direkt via Internet-Download auf den Raspberry Pi. Alternativ kann das Programm z. B. auch als Textdatei mit einem USB-Stick auf den Raspberry Pi \u00fcbertragen werden. In der Thonny IDE sieht das Programm so aus, wie in Bild 8 <\/mark>zu sehen. Nach dem Starten des Programms (\u00fcber das gr\u00fcne Start-Symbol mit dem wei\u00dfen Pfeil) beginnt die angeschlossene LED zu blinken.<\/p>\n<\/div>\n\n\n\n
              \n
              \"Python-Programm
              Bild 8: Python-Programm in der Thonny IDE<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
              Wie arbeitet der Code?<\/h2>\n\n\n\n
              Die erste Zeile des Programms importiert das RPi.GPIO-Modul, das ben\u00f6tigt wird, um auf die GPIO-Pins zuzugreifen. Dann erfolgt der Import des time-Moduls, das u. a. Programmpausen erm\u00f6glicht. Die n\u00e4chsten Zeilen setzen die Variable \u201eled_pin“ auf 18 und legen den Modus der GPIO-Pins auf BCM (\u201eBroadcom“-Nummerierung) fest. Die Zeile GPIO.setup(led_pin, GPIO.OUT) konfiguriert den led_pin als Ausgangspin (Output). Die folgende \u201ewhile“-Schleife wird ohne Ende durchlaufen, da \u201eTrue“ als Schleifenbedingung angegeben ist. Innerhalb der Schleife wird zuerst der led_pin auf HIGH gesetzt, um die LED einzuschalten, dann wird time.sleep(0.5) aufgerufen, um eine Pause von 0,5 Sekunden einzulegen.<\/p>\n\n\n\n
              Anschlie\u00dfend wird der led_pin auf LOW gesetzt, um die LED auszuschalten, dann folgt erneut eine Pause von 0,5 Sekunden. Die Schleife wird dann von vorne gestartet, und der Zyklus wiederholt sich, wodurch die LED abwechselnd ein- und ausgeschaltet wird. Das Programm erzeugt also eine Blinksequenz, bei der die LED alle 0,5 Sekunden ein- und ausgeschaltet wird. Die Blinkfrequenz der LED betr\u00e4gt dabei:<\/p>\n\n\n\n
                        f = 1\/T = 1\/(0,5 s +0,5 s) = 1\/1 s = 1 Hz<\/p>\n\n\n\n
              Nach dem Programmstart blinkt die LED daher im gut erkennbaren Sekundentakt. Obwohl das Programm einwandfrei arbeitet, wird in der Konsole eine Warnmeldung ausgegeben:<\/p>\n\n\n\n
              \n
              RuntimeWarning: This channel is already in use …<\/strong><\/p>\n<\/blockquote>\n\n\n\n
              Diese weist darauf hin, dass die 10-Ports eventuell bereits in fr\u00fcheren Anwendungen zum Einsatz gekommen sind. In dieser einfachsten Programmversion wurde zun\u00e4chst auf eine klare Definition des Pin-Zustands beim Programmstart verzichtet. Das Programm arbeitet jedoch trotz der Warnung problemlos. Weitere Hinweise hierzu finden sich im n\u00e4chsten Abschnitt.<\/p>\n\n\n\n
              \n
              \n
              Anstelle der einfachen LED kann auch eine Logic-Level-Anzeige verwendet werden. Ein entsprechendes Modul ist im PAD6<\/span> enthalten. Diese Pegelanzeige wird sowohl mit der Betriebsspannung des Raspberry Pi von 3,3 V als auch mit Ground (GND) verbunden. Ohne weitere Beschaltung leuchten die acht roten und acht gr\u00fcnen LEDs des Moduls schwach auf und zeigen damit einen \u201eundefinierten“ Logikpegel an (Bild 9)<\/mark>.<\/p>\n<\/div>\n\n\n\n
              \n
              \"Undefinierter
              Bild 9: Undefinierter Pegel am Logic-Level-Modul<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
              Wird der aktive Ausgangspin des Raspberry Pi (I\/0 Nummer 18) mit dem ersten Kanal der Logic-Level-Anzeige verbunden, blinken die rote und gr\u00fcne LED dieses Kanals im Wechseltakt. Damit wird der Pegelwechsel des Pins (0 V: LOW-Pegel, 3,3 V: HIGH-Pegel) sehr anschaulich demonstriert (Bild 10)<\/mark>.<\/p>\n\n\n\n
              \n
              \n
              \"Pegel
              Bild 10: Pegel HIGH (3,3 V) und LOW (0 V) am Logic-Level-Modul<\/figcaption><\/figure>\n<\/div>\n\n\n\n
              \n
              \"Pegel<\/figure>\n<\/div>\n<\/div>\n\n\n\n
              Programme definiert beenden<\/h2>\n\n\n\n
              Im Gegensatz zu den anderen sieben Kan\u00e4len hat der Eingang nun ein definiertes HIGH\/LOW-Signal, das entsprechend angezeigt wird. Wird das Programm \u00fcber das Stopp-Symbol (roter Kreis mit wei\u00dfem Quadrat in der Thonny IDE) oder \u00fcber die Tastenkombination Ctrl-C (bzw. Strg-C) angehalten, bleibt entweder die rote oder die gr\u00fcne LED dauerhaft eingeschaltet. Welche LED aktiv bleibt, h\u00e4ngt davon ab, in welchem Zustand der Port beim Beenden aktiv war.<\/p>\n\n\n\n
              Dieses Verhalten ist in vielen Anwendungsf\u00e4llen unerw\u00fcnscht. Wenn auf diese Weise z. B. eine Maschine gesteuert wird, ist nach einem Programmabbruch der genaue Zustand des Ger\u00e4ts nicht definiert. Dies kann bei gr\u00f6\u00dferen Systemen zu gef\u00e4hrlichen Situationen f\u00fchren.<\/p>\n\n\n\n
              Es ist daher sinnvoll, das Programm (try_except.py) folgenderma\u00dfen zu erweitern:<\/p>\n\n\n\n
              import RPi.GPIO as GPIO\nimport time\n\nLedPin = 18\n\nGPIO.setmode(GPIO.BCM)      # Numbers GPIOs by physical location\nGPIO.setup(LedPin, GPIO.OUT) # Set LedPin's mode is output\n\ntry:\n    while True:\n        print('...led on')\n        GPIO.output(LedPin, GPIO.LOW) # led on\n        time.sleep(0.5)\n        print('led off...')\n        GPIO.output(LedPin, GPIO.HIGH) # led off\n        time.sleep(0.5)\n\nexcept KeyboardInterrupt: # When 'Ctrl+C' is pressed, the following code will be executed.\n    GPIO.output(LedPin, GPIO.LOW) # led off\n    GPIO.cleanup()              # Release resource\n    print('bye...')<\/code><\/pre>\n\n\n\n
              <\/div>\n\n\n\n
              Hier wird die Hauptschleife in eine \u201etry\/except“-Konstruktion eingeschlossen. Im \u201eexcept“-Zweig wird ein Keyboard-Interrupt definiert, der einen kontrollierten Programmabbruch erm\u00f6glicht. Wenn das Programm \u00fcber Ctrl-C beendet wird, wird der Port in den LOW-Zustand versetzt. Die Anweisung \u201eGPIO.cleanup()“ sorgt zudem daf\u00fcr, dass die verwendeten Ressourcen, also die GPIO-Pins, programmtechnisch wieder freigegeben werden.<\/p>\n\n\n\n
              Zus\u00e4tzlich werden in der Konsole weitere Informationen ausgegeben. \u00dcber die \u201eprint“-Anweisung wird angezeigt, ob die LED gerade ein- oder ausgeschaltet ist. Am Ende liefert die Ausgabe \u201ebye…“ in der Konsole die Information, dass das Programm ordnungsgem\u00e4\u00df beendet wurde.<\/p>\n\n\n\n
              Auf der Hardwareseite ist dies daran erkennbar, dass alle LEDs des Logic-Pegel-Moduls nach Programmende via Ctrl-C nur noch schwach leuchten. Das bedeutet, dass der verwendete Ausgang nun hochohmig, also inaktiv ist. Dies ist typischerweise der erw\u00fcnschte Zustand nach dem Beenden eines Programms. Wird das Programm dagegen \u00fcber das Stopp-Symbol abgebrochen, entsteht wieder der bereits bekannte undefinierte Zustand. Eine weitere Wirkung einer definierten Programmbeendigung zeigt sich beim Neustart. Wurde das Programm mit Ctrl-C beendet, wird kein Warnhinweis mehr ausgegeben, da die Systemressourcen in diesem Fall ordnungsgem\u00e4\u00df freigegeben wurden. Beim Abbruch \u00fcber das Stopp-Symbol wird dagegen nach einem Neustart wieder die bekannte Warnung angezeigt.<\/p>\n\n\n\n
              <\/div>\n\n\n\n
              Mini-Voltmeter als Logic-Analyzer<\/h2>\n\n\n\n
              \n
              \n
              Das Mini-Voltmeter ist ein \u00e4u\u00dferst n\u00fctzliches Modul, wenn es darum geht, Spannungspegel schnell und pr\u00e4zise zu erfassen. Bild 11<\/mark> zeigt das Modul mit den Betriebsspannungen (5 V und 3,3 V) des Raspberry Pi.<\/p>\n<\/div>\n\n\n\n
              \n
              \"Betriebsspannungen
              Bild 11: Die Betriebsspannungen des Raspberry Pi auf dem Mini-Voltmeter<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
              Neben den Betriebsanzeigen kann das Modul jedoch auch noch weitere wichtige Aufgaben \u00fcbernehmen. So ist es bei der Arbeit mit dem Raspberry Pi oftmals erforderlich, auch den zeitlichen Verlauf von Spannungspegeln zu erfassen. Auch hier kann das Mini-Voltmeter nutzbringend eingesetzt werden.<\/p>\n\n\n\n
              \n
              \n
              Bild 12<\/mark> zeigt den Spannungsverlauf am Port 18, wenn das obige Programm aktiv ist. Zur Verdeutlichung wurden die Schaltzeiten auf 1,5 Sekunden erh\u00f6ht. Nun kann man den zeitlichen Spannungsverlauf, also das Umschalten zwischen 0 V und 3,3 V sehr gut erkennen. Das Modul dient hier als einfacher Logic-Analyzer. Der erste Kanal (Input 1) zeigt dagegen nach wie vor die konstante Eingangsspannung des Raspberry Pi von 5,0 V an.<\/p>\n<\/div>\n\n\n\n
              \n
              \"Logikpegelverlauf
              Bild 12: Logikpegelverlauf an Port 18 auf dem Mini-Voltmeter<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
              Fazit und Ausblick<\/h2>\n\n\n\n
              Im ersten Teil dieses Python-Grundkurses wurde der Start der Programmierumgebung vorgestellt und erl\u00e4utert. Die ersten Programme erm\u00f6glichten bereits den Zugriff auf einfache Hardwarekomponenten wie LEDs.<\/p>\n\n\n\n
              Im n\u00e4chsten Beitrag werden die I\/O-Ports genauer unter die Lupe genommen. Es wird gezeigt, dass die Pins des Raspberry Pi nicht nur als Ausg\u00e4nge, sondern auch als Eing\u00e4nge deklariert werden k\u00f6nnen. Damit lassen sich Tastensteuerungen oder Reed-Relais-Schaltungen aufbauen.<\/p>\n\n\n\n
              Es werden auch die Probleme des Tastenprellens genauer betrachtet und L\u00f6sungsvorschl\u00e4ge diskutiert. Zudem wird die Strombelastbarkeit der Pins untersucht. Genauere Kenntnisse zu diesem Thema k\u00f6nnen helfen, \u00dcberlastungen des Raspberry Pi zu verhindern. <\/p>\n\n\n\n
              <\/div>\n\n\n\n
              Material<\/h2>\n\n\n\n
                \n
              • Raspberry Pi mit Netzteil<\/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":"
                Starten Sie den Einstieg in Python! In Teil 1 lernen Sie die Grundlagen der beliebten Programmiersprache kennen \u2013 praxisnah mit Raspberry Pi, MicroPython, Thonny IDE und ersten Hardware-Beispielen wie einer blinkenden LED.<\/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":[944,947,949,946,945,950,948],"post-author":[137],"class_list":["post-4342","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python-micropython","tag-micropython","tag-python-einsteiger","tag-python-gpio","tag-python-leds-steuern","tag-python-lernen-raspberry-pi","tag-python-programmierung-hardware","tag-python-thonny-ide","post-author-dr-guenter-spanner"],"acf":[],"info":{"thumbnail":{"url":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/header_phyton_teil11.jpg","alt":""},"teaserImage":{"ID":4825,"id":4825,"title":"liste-beitrag_python_t1_neu","filename":"Liste-Beitrag_python_t1_neu.jpg","filesize":96343,"url":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t1_neu.jpg","link":"https:\/\/de.elv.com\/elvjournal\/python-einstieg-raspberry-pi-teil1\/liste-beitrag_python_t1_neu\/","alt":"","author":"5","description":"","caption":"","name":"liste-beitrag_python_t1_neu","status":"inherit","uploaded_to":4342,"date":"2025-09-29 12:18:53","modified":"2025-09-29 12:20:14","menu_order":0,"mime_type":"image\/jpeg","type":"image","subtype":"jpeg","icon":"https:\/\/elvjournal.elv.com\/wp-includes\/images\/media\/default.png","width":433,"height":274,"sizes":{"thumbnail":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t1_neu-250x250.jpg","thumbnail-width":250,"thumbnail-height":250,"medium":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t1_neu-300x190.jpg","medium-width":300,"medium-height":190,"medium_large":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t1_neu.jpg","medium_large-width":433,"medium_large-height":274,"large":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t1_neu.jpg","large-width":433,"large-height":274,"1536x1536":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t1_neu.jpg","1536x1536-width":433,"1536x1536-height":274,"2048x2048":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t1_neu.jpg","2048x2048-width":433,"2048x2048-height":274,"gform-image-choice-sm":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t1_neu.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_t1_neu.jpg","gform-image-choice-md-width":400,"gform-image-choice-md-height":253,"gform-image-choice-lg":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t1_neu.jpg","gform-image-choice-lg-width":433,"gform-image-choice-lg-height":274}},"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":"19. Februar 2026","excerpt":"Starten Sie den Einstieg in Python! In Teil 1 lernen Sie die Grundlagen der beliebten Programmiersprache kennen \u2013 praxisnah mit Raspberry Pi, MicroPython, Thonny IDE und ersten Hardware-Beispielen wie einer blinkenden LED."},"_links":{"self":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/4342","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=4342"}],"version-history":[{"count":9,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/4342\/revisions"}],"predecessor-version":[{"id":11286,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/4342\/revisions\/11286"}],"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=4342"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/categories?post=4342"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/tags?post=4342"},{"taxonomy":"post-author","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/post-author?post=4342"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}