Przewodnik po GPIO dla początkujących

Przez Nathan Busler | 11 marca 2022 r.

W tym wpisie na blogu dowiesz się wszystkiego o pinach GPIO w Raspberry Pi. Ten wpis jest przeznaczony przede wszystkim dla początkujących elektroników.

Po pierwsze, ostrzeżenie:

Raspberry Pi może zostać nieodwracalnie uszkodzone, jeśli styki zostaną użyte niepoprawnie. Dlatego zawsze upewnij się, że Twój obwód jest poprawny i że używasz wystarczającej liczby rezystorów.

Co to są piny GPIO

Piny GPIO to 40 małych metalowych pinów znajdujących się w górnej części Raspberry Pi. Skrót GPIO oznacza General Purpose Input Output (wejście i wyjście ogólnego przeznaczenia). Oznacza to, że piny GPIO mogą być używane jako interfejs dla prawie każdego urządzenia elektronicznego.

Ze względu na dużą liczbę sposobów (niewłaściwego) wykorzystania pinów, rozpoczęcie pracy może być nieco mylące. Dlatego ten wpis na blogu zawiera kilka przykładów, jak kontrolować piny za pomocą Bash, C i Python. Niewielkie doświadczenie w programowaniu jest więc zaletą.

Mimo że 40 pinów wygląda identycznie, mają one różne funkcje. 26 pinów może być wykorzystanych do GPIO, a niektóre mają dodatkowe funkcje. Kolejne 4 piny są wykorzystywane jako źródło zasilania (POWER, dwa razy 3V3 i dwa razy 5V), a 8 jako biegun ujemny (również masa lub GROUND). Dwa pozostałe piny to interfejs I2C dla pamięci EEPROM ID.

Rozkład pinów

Poniższa grafika przedstawia najważniejsze informacje, między innymi wyprowadzenie pinów. Rozkład pinów jest identyczny dla większości modeli Raspberry Pi, ale istnieją różnice. Zawsze przed podłączeniem urządzenia należy sprawdzić dokładny rozkład pinów dla danego modelu. W tym celu wystarczy otworzyć terminal na swoim Raspberry Pi (Ctrl+Alt+t) i wykonać następujące polecenie.

pinout

Zobaczysz grafikę wszystkich połączeń i dokładny układ pinów Twojego Raspberry Pi.

Być może zauważyłeś, że numery GPIO pojawiają się losowo i nie odpowiadają numeracji pinów. Aby uniknąć pomyłek, numerację od 1 do 40 określam jako numer BOARD, a numer od 1 do 26 jako numer BCM lub GPIO.

Tak więc pin 1 BOARD to złącze 3V3 POWER, a pin 2 GPIO to znajdujący się obok pin o numerze 3 BOARD.

Jak podłączyć urządzenie do styków

Istnieje kilka alternatywnych sposobów podłączenia urządzenia do pinów GPIO. Niektóre urządzenia mają nagłówek GPIO, dzięki czemu urządzenie można podłączyć bezpośrednio do pinów GPIO. Zazwyczaj jednak nie jest to możliwe, dlatego stosuje się zworki lub przedłużacze GPIO.

Oglądaj nasze Wideo o GPIO Pins!

W poniższym przykładzie dioda LED jest podłączona do Raspberry Pi za pomocą zworki.

Obwód

Zworka żeńsko-męska łączy pin GPIO z płytą czołową lub płytką drukowaną. Następnie pin musi zostać zaprogramowany do obsługi urządzenia. Urządzenie może być przyciskiem, diodą LED, czujnikiem, silnikiem lub wyświetlaczem. Ważne jest tylko, aby urządzenie mogło być zasilane napięciem 5 V lub mniejszym oraz aby było kompatybilne z interfejsami I2C, SPI lub UART.

Do budowy potrzebne są następujące urządzenia.

Raspberry Pi z systemem operacyjnym Raspberry Pi
Dwa przewody łączące męskie i żeńskie
Jeden przewód łączący męski z męskim
Rezystor 10 kilo Ohm
LED
Płyta bezlutowa

Podłącz pin GPIO 13 (numer BOARD 33) do + pasek a znajdujący się obok niego bolec GROUND (BOARD nr 34) do - listwa na płytce drukowanej. Następnie podłącz jeden koniec rezystora 10 kilo Ohm (dowolnego rezystora) do złącza + pasek a drugi koniec do jednego z pasków poprzecznych. W przypadku diody LED kluczowe znaczenie ma jej orientacja. Anoda to dłuższe z dwóch ramion i często wygięte, katoda to krótsze ramię. Anoda musi być zawsze skierowana w stronę + w kierunku, tj. w stronę źródła zasilania, a katoda w kierunku – czyli w kierunku Uziemienia. Dlatego dłuższe ramię należy umieścić w tej samej listwie poprzecznej co rezystor, a krótsze w sąsiedniej. Na koniec użyj zworki męsko-męskiej, aby połączyć poprzeczkę katody (krótsze ramię diody LED) z opornikiem. - listwa.

Poniższy schemat przedstawia montaż. Upewnij się, że wszystko jest prawidłowo zamontowane i że elementy są włożone do płytki do oporu, w przeciwnym razie styki będą luźne.

Poniższe trzy przykłady kodu w językach Bash, Python i C są oparte na tej strukturze. Jeśli używasz innych pinów, musisz odpowiednio zmodyfikować kod.

Bash

Kontrolowanie pinów GPIO za pomocą Basha jest bardzo proste. W systemie Linux sterowanie pinami GPIO odbywa się za pomocą plików w katalogu /sys/class/gpio folder. Aby użyć styku GPIO, należy go najpierw wyeksportować. Jako przykładu używam pinu GPIO 13. W dalszej części nazwy plików są pogrubione i wyróżnione kursywą.

Otwórz terminal i wylistuj zawartość folderu gpio.

cd /sys/class/gpio
ls

Folder zawiera pliki eksportu i niewyeksportowania oraz podfoldery dla każdego eksportowanego pinu GPIO.

Eksportujemy pin, wpisując numer GPIO do /sys/class/gpio/export plik. Wykonaj to polecenie w terminalu.

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

Teraz został utworzony folder z odpowiednim numerem pinu gpio13. Folder ten zawiera inne foldery i pliki. Na razie ważne są dla nas tylko pliki kierunku i wartości.

Strona kierunek W pliku zapisywany jest tryb pracy styku:

w -> Pin jest w trybie odczytu lub wejścia

na zewnątrz -> Pin jest w trybie zapisu lub wyjścia

Strona wartość Plik przechowuje stan napięcia na styku:

0 -> styk jest w trybie LOW -> do styku nie jest przyłożone napięcie

1 -> Pin jest w trybie HIGH -> Do pinu przyłożone jest napięcie

Następujące polecenia ustawiają tryb pracy na na zewnątrz a wartość do 1.

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

Dioda LED jest teraz zapalona. Ważne jest, aby po użyciu zresetować wartości styków. Po każdym użyciu należy wykonać następujące polecenia.

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

Program w języku Python

Teraz wyabstrahujemy i zautomatyzujemy te polecenia Basha w Pythonie.

Poniższy skrypt Pythona umożliwia wykonanie prostego GPIO_Pin klasa. Dzięki temu jest ona niezwykle łatwa w użyciu. Strona os Moduł ten umożliwia wykonywanie tych samych poleceń basha, co powyżej, z poziomu Pythona. Nie wiem, jak to zrobić. Dzięki temu nie trzeba już ręcznie resetować i eksportować pinów.

import os
from time import sleep

class GPIO_Pin:
    def __init__(self, num, mode):
        if 0 <= num or num <= 40:
            self.num = num
        else:
            print('Invalid Pin Number -> Enter a number from 0 - 40')
        if mode == 'out' or mode == 'write':
            self.mode = 'out'
        elif mode == 'in' or mode == 'read':
            self.mode = 'in'
        else:
            print('Invalid Pin Mode -> Enter "out" or "write" for output, "in" or "read" for input')
        if self.num and 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 or value == 'LOW':
            os.system(f'echo 0 > /sys/class/gpio/gpio{str(self.num)}/value')
        elif value == 1 or value == 'HIGH':
            os.system(f'echo 1 > /sys/class/gpio/gpio{str(self.num)}/value')
        else:
            print('Invalid value -> Enter 1 or "HIGH" for HIGH, 0 or "LOW" for LOW')

    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')
    number_of_blinks = 10
    for i in range(number_of_blinks):
        pin.write('HIGH')
        sleep(0.5)
        pin.write('LOW')
        sleep(0.5)

if __name__ == '__main__':
    main()

Dzięki modułowi czasowemu możemy nawet bez problemu sprawić, że dioda LED zacznie mrugać. Cały skrypt można rozbudować do modułu Pythona do sterowania GPIO.

Program C

Również w języku C możemy łatwo edytować zawartość folderu gpio. Korzystając z biblioteki standardowej stdlib możemy otwierać pliki i zmieniać ich zawartość.
Poniższy program w języku C musi zostać skompilowany, zanim będzie mógł zostać wykonany. Utwórz plik gpio.c i skopiuj do niego program.
Następnie należy otworzyć terminal i przejść do folderu, w którym znajduje się plik gpio.c znajduje się plik. Do skompilowania i wykonania programu należy użyć następujących poleceń.

gcc -o gpio gpio.c
./gpio

Poniżej przedstawiamy program.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#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("Failed to open the export file\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("Failed to open the unexport file\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("Failed to open the direction file\n");
        exit(-1);
    }
    fputs(mode, direction);
    fclose(direction);
    return 0;
}

int set_value(int val, int num) {
    char value_file_path[1024];
    snprintf(value_file_path, sizeof(value_file_path), "/sys/class/gpio/gpio%d/value", num);
    FILE* value = fopen(value_file_path, "w");
    if (value == NULL) {
        printf("Failed to open the value file\n");
        exit(-1);
    }
    fprintf(value, "%d", val);
    fclose(value);
    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 - aplikacja GPIO

Najprostszym sposobem sterowania pinami GPIO jest użycie aplikacji GPIO App. Na stronie Interfejs sieciowy PiCockpit jest bezpłatny dla maksymalnie 5 komputerów Raspberry Pi. Ma on dwie duże zalety: Nie musisz znać się na programowaniu, aby sterować pinami GPIO i możesz to robić z dowolnego miejsca.

Wystarczy zainstalować klienta PiCockpit na swoim Raspberry Pi i połączyć się z kontem PiCockpit. Następnie można łatwo sterować pinami GPIO za pomocą interfejsu WWW.

Następne kroki

Teraz już wiesz, jak korzystać z pinów GPIO za pomocą zworek. Oczywiście istnieją również zewnętrzne moduły Pythona i biblioteki C do sterowania pinami GPIO. Dobrym następnym krokiem byłoby rozszerzenie jednego z przykładów kodu. Na przykład za pomocą dodatkowych diod LED lub przycisku.

Miłego eksperymentowania!