GPIO-Anleitung für Anfänger

In diesem Blogbeitrag erfahren Sie alles über die GPIO-Pins des Raspberry Pi. Dieser Beitrag ist vor allem für Neulinge in der Elektronik gedacht.

Zunächst einmal eine Warnung
Der Raspberry Pi kann irreparabel beschädigt werden, wenn die Pins falsch verwendet werden. Achten Sie also immer darauf, dass Ihre Schaltung korrekt ist und dass Sie genügend Widerstände verwenden.

Was sind GPIO-Pins?

Die GPIO-Pins sind die 40 kleinen Metallstifte auf der Oberseite des Raspberry Pi. Die Abkürzung GPIO steht für General Purpose Input Output. Das bedeutet, dass die GPIO-Pins als Schnittstelle für fast jedes elektronische Gerät verwendet werden können.

Aufgrund der großen Anzahl von Möglichkeiten, die Pins (falsch) zu verwenden, kann der Einstieg etwas verwirrend sein. In diesem Blogbeitrag finden Sie daher einige Beispiele, wie Sie die Pins mit Bash, C und Python steuern können. Ein wenig Erfahrung in der Programmierung ist also von Vorteil.

Obwohl die 40 Pins identisch aussehen, haben sie unterschiedliche Funktionen. 26 Pins können für GPIO verwendet werden und einige haben zusätzliche Funktionen. Weitere 4 Pins werden als Stromquelle (POWER, zweimal 3V3 und zweimal 5V) und 8 als Minuspol (auch Masse oder GROUND) verwendet. Die beiden verbleibenden Pins sind die I2C-Schnittstelle für ID EEPROM.

Pinout

Die Grafik unten zeigt die wichtigsten Informationen, u.a. die Pinbelegung. Die Pinbelegung ist bei den meisten Raspberry Pi-Modellen identisch, aber es gibt Unterschiede. Prüfen Sie immer die genaue Pinbelegung Ihres Modells, bevor Sie ein Gerät anschließen. Dazu müssen Sie nur ein Terminal auf Ihrem Raspberry Pi öffnen (Strg+Alt+t) und den folgenden Befehl ausführen.

Pinbelegung

Sie sehen eine Grafik mit allen Anschlüssen und der genauen Pinbelegung Ihres Raspberry Pi.

Raspberry Pi Pinbelegung

Sie haben vielleicht bemerkt, dass die GPIO-Nummern zufällig erscheinen und nicht mit der Pin-Nummerierung übereinstimmen. Um Verwirrung zu vermeiden, bezeichne ich die Nummerierung von 1 bis 40 als BOARD-Nummer und die Nummer von 1 bis 26 als BCM- oder GPIO-Nummer.

BOARD-Pin 1 ist also der 3V3 POWER-Anschluss und GPIO-Pin 2 ist der Pin daneben mit der BOARD-Nummer 3.

So schließen Sie ein Gerät an die Stifte an

Es gibt mehrere Möglichkeiten, ein Gerät an die GPIO-Pins anzuschließen. Einige Geräte haben einen GPIO-Header, so dass das Gerät direkt an die GPIO-Pins angeschlossen werden kann. In der Regel ist dies jedoch nicht der Fall, weshalb Überbrückungsdrähte oder GPIO-Verlängerungskabel verwendet werden.

Siehe unser Video über GPIO-Pins!

Im folgenden Beispiel wird eine LED mit Hilfe von Jumperkabeln an den Raspberry Pi angeschlossen.

Die Schaltung

Mit dem Jumper Female to Male wird der GPIO-Pin mit einer Stiftleiste oder einem Breadboard verbunden. Der Pin muss dann programmiert werden, um das Gerät zu bedienen. Das Gerät kann eine Taste, eine LED, ein Sensor, ein Motor oder ein Display sein. Wichtig ist nur, dass das Gerät mit 5 Volt oder weniger betrieben werden kann und dass es mit den Schnittstellen I2C, SPI oder UART kompatibel ist.

Für den Bau benötigen wir die folgende Ausrüstung.

  • Raspberry Pi mit Raspberry Pi OS
  • Zwei Überbrückungsdrähte von männlich zu weiblich
  • Ein Überbrückungsdraht von Stecker zu Stecker
  • 10 Kilo-Ohm-Widerstand
  • LED
  • Lötfreies Breadboard

Verbinden Sie GPIO-Pin 13 (BOARD-Nummer 33) mit dem + Streifen und den daneben liegenden GROUND-Stift (BOARD-Nummer 34) mit dem - sich ausziehen des Breadboards. Stecken Sie dann ein Ende des 10-Kilo-Ohm-Widerstands (beliebiger Widerstand) in den + Streifen und das andere Ende in einen der Querstreifen. Für die LED ist die Ausrichtung entscheidend. Die Anode ist der längere der beiden Arme und oft gebogen, die Kathode ist der kürzere Arm. Die Anode muss immer in Richtung der + Richtung, d.h. zur Stromquelle hin, und die Kathode in der Richtung, d. h. gegen ERDE. Stecken Sie also den längeren Arm in dieselbe Querleiste wie den Widerstand, so dass sich der kürzere Arm in der benachbarten Querleiste befindet. Verwenden Sie schließlich das Überbrückungskabel von Stecker zu Stecker, um die Querleiste der Kathode (kürzerer Arm der LED) mit dem - sich ausziehen.

Die folgende Abbildung zeigt den Zusammenbau. Achten Sie darauf, dass alles korrekt ist und die Bauteile bis zum Anschlag in die Platine eingesteckt sind, da es sonst zu Wackelkontakten kommt.

Aufbau des Schaltkreises

Die folgenden drei Codebeispiele in Bash, Python und C basieren auf dieser Struktur. Wenn Sie andere Pins verwenden, müssen Sie den Code entsprechend anpassen.

Bash

Die Steuerung der GPIO-Pins über die Bash ist sehr einfach. Unter Linux werden die GPIO-Pins durch die Dateien im Verzeichnis /sys/class/gpio Ordner. Um einen GPIO-Pin zu verwenden, muss er zunächst exportiert werden. Als Beispiel verwende ich GPIO-Pin 13. Im Folgenden sind die Dateinamen fett und kursiv dargestellt.

Öffnen Sie ein Terminal und listen Sie den Inhalt des Ordners gpio auf.

cd /sys/class/gpio
ls

Der Ordner enthält die Dateien export und unexport sowie Unterordner für jeden exportierten GPIO-Pin.

Wir exportieren den Pin, indem wir die GPIO-Nummer in die Datei /sys/class/gpio/export Datei. Führen Sie diesen Befehl im Terminal aus.

echo 13 > /sys/class/gpio/export
ls

Nun wurde ein Ordner mit der entsprechenden Pin-Nummer gpio13 erstellt. Dieser Ordner enthält weitere Ordner und Dateien. Für uns sind vorerst nur die Richtungs- und Wertedateien wichtig.

Die Richtung Datei speichert den Modus des Pins:

in -> Pin ist im Lese- oder Eingangsmodus

aus -> Pin ist im Schreib- oder Ausgabemodus

Die Wert Datei speichert den Spannungszustand des Pins:

0 -> Pin ist im LOW-Modus -> keine Spannung liegt an dem Pin an

1 -> Pin ist im HIGH-Modus -> Spannung liegt am Pin an

Die folgenden Befehle setzen den Modus auf aus und der Wert auf 1.

echo out > /sys/class/gpio/gpio13/direction
echo 1 > /sys/class/gpio/gpio13/wert

Die LED leuchtet jetzt. Es ist wichtig, die Pin-Werte nach dem Gebrauch zurückzusetzen. Die folgenden Befehle sollten nach jeder Verwendung ausgeführt werden.

echo 0 > /sys/class/gpio/gpio13/value
echo in > /sys/class/gpio/gpio13/richtung
echo 13 > /sys/class/gpio/unexport

Python-Programm

Jetzt abstrahieren und automatisieren wir diese Bash-Befehle in Python.

Das folgende Python-Skript bietet eine einfache GPIO_Pin Klasse. Das macht die Benutzung extrem einfach. Die os Modul erlaubt es uns, die gleichen Bash-Befehle wie oben von Python aus auszuführen. Außerdem können wir durch die Verwendung der __del__ Methode müssen wir die Pins nicht mehr manuell zurücksetzen und neu exportieren.

os importieren
from time import sleep

class GPIO_Pin:
    def __init__(self, num, mode):
        if 0 <= num oder num  Enter a number from 0 - 40')
        if mode == 'out' oder mode == 'write':
            self.mode = 'out'
        elif mode == 'in' oder mode == 'read':
            self.mode = 'in'
        else:
            print('Ungültiger Pin-Modus -> Für Ausgabe "out" oder "write" eingeben, für Eingabe "in" oder "read"')
        if self.num und self.mode:
            os.system(f'echo {str(self.num)} > /sys/class/gpio/export')
            sleep(0.05)
            os.system(f'echo {self.mode} > /sys/class/gpio/gpio{str(self.num)}/direction')

    def reset(self):
        os.system(f'echo 0 > /sys/class/gpio/gpio{str(self.num)}/value')
        os.system(f'echo in > /sys/class/gpio/gpio{str(self.num)}/direction')

    def write(self, value):
        if value == 0 oder value == 'LOW':
            os.system(f'echo 0 > /sys/class/gpio/gpio{str(self.num)}/value')
        elif wert == 1 oder wert == 'HIGH':
            os.system(f'echo 1 > /sys/class/gpio/gpio{str(self.num)}/value')
        sonst:
            print('Ungültiger Wert -> Geben Sie 1 oder "HIGH" für HIGH, 0 oder "LOW" für LOW ein')

    def __del__(self):
        self.reset()
        os.system(f'echo {str(self.num)} > /sys/class/gpio/unexport')

    def set_mode(self, mode):
        self.mode = mode
        os.system(f'echo {str(self.mode)} > /sys/class/gpio/gpio{str(self.num)}/direction')

def main():
    pin = GPIO_Pin(13, 'out')
    anzahl_der_blinks = 10
    for i in range(anzahl_der_blinks):
        pin.write('HIGH')
        sleep(0.5)
        pin.write('LOW')
        sleep(0.5)

if __name__ == '__main__':
    main()

Mit dem Zeitmodul können wir sogar die LED problemlos zum Blinken bringen. Das ganze Skript kann zu einem Python-Modul für die GPIO-Steuerung erweitert werden.

C-Programm

Auch in C können wir den Inhalt des gpio-Ordners leicht bearbeiten. Verwendung der Standardbibliothek stdlib können wir Dateien öffnen und ihren Inhalt ändern.
Das folgende C-Programm muss kompiliert werden, bevor es ausgeführt werden kann. Erstellen Sie eine Datei gpio.c und kopieren Sie das Programm dorthin.
Öffnen Sie dann ein Terminal und navigieren Sie zu dem Ordner, in dem die gpio.c Datei befindet. Verwenden Sie die folgenden Befehle, um das Programm zu kompilieren und auszuführen.

gcc -o gpio gpio.c
./gpio

Hier ist das Programm.

#include 
#include 
#include 

#define GPIO_ROOT "/sys/class/gpio"
#define EXPORT "/sys/class/gpio/export"
#define UNEXPORT "/sys/class/gpio/export"

#define LOW 0
#define HIGH 1

int export_pin(int num) {
    FILE* export = fopen(EXPORT, "w");
    if (export == NULL) {
        printf("Die Exportdatei konnte nicht geöffnet werden\n");
        exit(-1);
    }
    fprintf(export, "%d", num);
    fclose(export);
    return 0;
}

int unexport_pin(int num) {
    FILE* unexport = fopen(UNEXPORT, "w");
    if (unexport == NULL) {
        printf("Die Datei unexport konnte nicht geöffnet werden\n");
        exit(-1);
    }
    fprintf(unexport, "%d", num);
    fclose(unexport);
    return 0;
}

int set_direction(char *mode, int num) {
    char direction_file_path[1024];
    snprintf(direction_file_path, sizeof(direction_file_path), "/sys/class/gpio/gpio%d/direction", num);
    FILE* direction = fopen(direction_file_path, "w");
    if (direction == NULL) {
        printf("Fehler beim Öffnen der Richtungsdatei\n");
        exit(-1);
    }
    fputs(mode, direction);
    fclose(direction);
    return 0;
}

int set_value(int val, int num) {
    char value_file_path[1024];
    snprintf(wert_file_pfad, sizeof(wert_file_pfad), "/sys/class/gpio/gpio%d/value", num);
    FILE* wert = fopen(wert_datei_pfad, "w");
    if (wert == NULL) {
        printf("Fehler beim Öffnen der Wertedatei\n");
        exit(-1);
    }
    fprintf(wert, "%d", val);
    fclose(wert);
    return 0;
}

int main() {

    int rslt;
    int num;
    int num_blinks;

    num = 13;
    num_blinks = 10;

    rslt = export_pin(num);
    rslt = set_direction("out", num);
    for (int i = 0; i < num_blinks; i++) {
        rslt = set_value(HIGH, num);
        sleep(1);
        rslt = set_value(LOW, num);
        sleep(1);
    }

    rslt = set_value(LOW, num);
    rslt = set_direction("in", num);
    rslt = unexport_pin(num);

    return EXIT_SUCCESS;
}

PiCockpit - GPIO Anwendung

Der einfachste Weg, die GPIO-Pins zu steuern, ist mit Hilfe der GPIO-App. Die PiCockpit Weboberfläche ist kostenlos für bis zu 5 Raspberry Pi. Es bietet zwei große Vorteile: Sie müssen keine Programmierkenntnisse haben, um Ihre GPIO-Pins zu steuern, und Sie können dies von überall aus tun.

Installieren Sie einfach den PiCockpit Client auf Ihrem Raspberry Pi und verbinden Sie sich mit Ihrem PiCockpit Konto. Danach können Sie die GPIO-Pins einfach über das Webinterface steuern.

Nächste Schritte

Jetzt wissen Sie, wie Sie die GPIO-Pins mit Hilfe von Jumper-Drähten verwenden können. Natürlich gibt es auch externe Python-Module und C-Bibliotheken zur Steuerung der GPIO-Pins. Ein guter nächster Schritt wäre es, eines der Code-Beispiele zu erweitern. Zum Beispiel durch die Verwendung zusätzlicher LEDs oder einer Taste.
Viel Spaß beim Experimentieren!

Hinterlassen Sie einen Kommentar