GPIO-guide för nybörjare

I det här blogginlägget får du lära dig allt om GPIO-stiften i Raspberry Pi. Det här inlägget är särskilt avsett för nybörjare inom elektronik.

Först och främst en varning
Raspberry Pi kan skadas ohjälpligt om stiften används felaktigt. Se därför alltid till att din krets är korrekt och att du använder tillräckligt många motstånd.

Vad är GPIO-stift?

GPIO-stiften är de 40 små metallstiften på toppen av Raspberry Pi. Förkortningen GPIO står för General Purpose Input Output. Det betyder att GPIO-stiften kan användas som ett gränssnitt för nästan vilken elektronisk enhet som helst.

På grund av det stora antalet olika sätt att (miss)använda pinnarna kan det vara lite förvirrande att komma igång. Därför ger det här blogginlägget några exempel på hur man kan styra pinnarna med hjälp av Bash, C och Python. Så lite erfarenhet av programmering är en fördel.

Även om de 40 stiften ser likadana ut har de olika funktioner. 26 stift kan användas för GPIO och vissa har ytterligare funktioner. Ytterligare 4 stift används som strömkälla (POWER, två gånger 3V3 och två gånger 5V) och 8 som negativ pol (även jord eller GROUND). De två återstående stiften är I2C-gränssnittet för ID EEPROM.

Pinout

Grafiken nedan visar den viktigaste informationen, bland annat pinout. Stiftuttaget är identiskt för de flesta Raspberry Pi-modeller, men det finns skillnader. Kontrollera alltid den exakta pinouten för din modell innan du ansluter en enhet. För detta behöver du bara öppna en terminal på din Raspberry Pi (Ctrl+Alt+t) och utföra följande kommando.

Pinout

Du kommer att se en grafisk bild av alla anslutningar och den exakta pinouten för din Raspberry Pi.

Raspberry Pi Pinout

Du kanske har lagt märke till att GPIO-numren visas slumpmässigt och inte stämmer överens med stiftnumreringen. För att undvika förvirring hänvisar jag till numreringen från 1 till 40 som BOARD-nummer och numret från 1 till 26 som BCM- eller GPIO-nummer.

Så BOARD pin 1 är 3V3 POWER-kontakten och GPIO pin 2 är pin 3 bredvid.

Hur man ansluter en enhet till stiftstiftet

Det finns flera alternativ för att ansluta en enhet till GPIO-stiften. Vissa enheter har ett GPIO-huvud så att enheten kan anslutas direkt till GPIO-stiften. I allmänhet är detta dock inte fallet, vilket är anledningen till att man använder jumpertrådar eller GPIO-förlängningskablar.

Titta på vår video om GPIO Pins!

I följande exempel är en lysdiod ansluten till Raspberry Pi med hjälp av bryggkablar.

Kretsen

Jumpertrådarna från hona till hane ansluter GPIO-stiftet till en header eller ett brödbräda. Stiftet måste sedan programmeras för att driva enheten. Enheten kan vara en knapp, en lysdiod, en sensor, en motor eller en display. Det är bara viktigt att enheten kan drivas med 5 volt eller mindre och att den är kompatibel med gränssnitten I2C, SPI eller UART.

För bygget behöver vi följande utrustning.

  • Raspberry Pi med Raspberry Pi OS
  • Två manliga till kvinnliga jumpertrådar
  • En manlig till manlig jumpertråd
  • Resistor på 10 kilo Ohm
  • LED
  • Lödlös brödskiva

Anslut GPIO-stift 13 (BOARD nummer 33) till den + band och GROUND-stiftet bredvid (BOARD nummer 34) till - remsa på brödbrädan. Anslut sedan den ena änden av 10 kilo-ohm-motståndet (vilket motstånd som helst) till + band och den andra änden i en av tvärbanden. För lysdioden är orienteringen avgörande. Anoden är den längre av de två armarna och ofta böjd, katoden är den kortare armen. Anoden måste alltid peka i den + riktning, dvs. mot strömkällan, och katoden i den andra riktningen. riktning, dvs. mot marken. Placera därför den längre armen i samma tvärband som motståndet, så att den kortare armen ligger i det intilliggande tvärbandet. Slutligen använder du en hane till hane-överbrytarkabel för att ansluta katodens tvärband (lysdiodens kortare arm) till - remsa.

Följande diagram visar monteringen, se till att allt är korrekt och att komponenterna är insatta i kortet så långt som möjligt, annars kommer det att bli lösa kontakter.

Uppbyggnad av Schaltkreises

Följande tre kodexempel i Bash, Python och C bygger på denna struktur. Om du använder andra stift måste du ändra koden i enlighet med detta.

Bash

Det är mycket enkelt att styra GPIO-stiften via Bash. I Linux styrs GPIO-pinnarna av filerna i /sys/class/gpio mapp. För att använda en GPIO-stift måste den först exporteras. Som exempel använder jag GPIO-stift 13. I det följande är filnamnen feta och kursiva.

Öppna en terminal och visa innehållet i mappen gpio.

cd /sys/class/gpio
ls

Mappen innehåller filerna export och unexport samt undermappar för varje exporterad GPIO-stift.

Vi exporterar pinnen genom att skriva GPIO-numret i /sys/class/gpio/export fil. Utför det här kommandot i terminalen.

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

Nu har en mapp med motsvarande pin-nummer gpio13 skapats. Denna mapp innehåller andra mappar och filer. För tillfället är det bara filerna för riktning och värde som är viktiga för oss.

The riktning sparar stiftets läge:

-> Pin är i läs- eller inmatningsläge

ut -> Pin är i skriv- eller utgångsläge

The värde sparar stiftets spänningstillstånd:

0 -> stift är i LOW-läge -> ingen spänning läggs på stiftet

1 -> Pin är i HIGH-läge -> Spänning appliceras på pinnen

Följande kommandon ställer in läget till ut och värdet till 1.

echo out > /sys/class/gpio/gpio13/direction
echo 1 > /sys/class/gpio/gpio13/värde

Lysdioden lyser nu. Det är viktigt att återställa stiftvärdena efter användning. Följande kommandon ska utföras efter varje användning.

echo 0 > /sys/class/gpio/gpio13/värde
echo in > /sys/class/gpio/gpio13/riktning
echo 13 > /sys/class/gpio/unexport

Python-program

Nu abstraherar och automatiserar vi dessa Bash-kommandon i Python.

Följande Python-skript ger en enkel GPIO_Pin klass. Detta gör den extremt lätt att använda. os modulen gör det möjligt att utföra samma bash-kommandon som ovan från Python. __del__ metoden behöver vi inte längre återställa och återexportera pinnarna manuellt.

importera os
från time importera sleep

klass GPIO_Pin:
    def __init__(self, num, mode):
        Om 0 <= num eller num  Ange ett nummer mellan 0 och 40')
        if mode == "out" eller mode == "write":
            self.mode = 'out'
        elif mode == "in" eller mode == "read":
            self.mode = "in".
        else:
            Skriv ut:: print('Invalid Pin Mode -> Ange "out" eller "write" för output, "in" eller "read" för input')
        Om self.num och 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)}/riktning')

    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)}/riktning')

    def write(self, value):
        if value == 0 or value == 'LOW':
            os.system(f'echo 0 > /sys/class/gpio/gpio{str(self.num)}/värde')
        elif value == 1 eller value == "HIGH":
            os.system(f'echo 1 > /sys/class/gpio/gpio{str(self.num)}/värde')
        else:
            print('Invalid value -> Ange 1 eller "HIGH" för HIGH, 0 eller "LOW" för 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)}/riktning')

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')
        sov(0,5)

if __name__ == '__main__':
    main()

Med tidsmodulen kan vi till och med få lysdioden att blinka utan problem. Hela skriptet kan utökas till en Python-modul för GPIO-styrning.

C Program

Även i C kan vi enkelt redigera innehållet i gpio-mappen. Genom att använda standardbiblioteket stdlib kan vi öppna filer och ändra innehållet.
Följande C-program måste kompileras innan det kan exekveras. Skapa en fil gpio.c och kopiera programmet dit.
Öppna sedan en terminal och navigera till den mapp där gpio.c filen är placerad. Använd följande kommandon för att kompilera och köra programmet.

gcc -o gpio gpio.c
./gpio

Här är programmet.

#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("Misslyckades att öppna exportfilen\n");
        exit(-1);
    }
    fprintf(export, "%d", num);
    fclose(export);
    returnera 0;
}

int unexport_pin(int num) {
    FILE* unexport = fopen(UNEXPORT, "w");
    if (unexport == NULL) {
        printf("Misslyckades att öppna unexport-filen\n");
        exit(-1);
    }
    fprintf(unexport, "%d", num);
    fclose(unexport);
    returnera 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, riktning);
    fclose(riktning);
    Återge 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);
    returnera 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-app

Det enklaste sättet att styra GPIO-stiften är med hjälp av GPIO-appen. PiCockpit webbgränssnitt är gratis för upp till 5 Raspberry Pi. Det har två stora fördelar: Du behöver inte kunna programmera för att styra dina GPIO-stift och du kan göra det var som helst.

Installera PiCockpit-klienten på din Raspberry Pi och anslut till ditt PiCockpit-konto. Därefter kan du enkelt styra GPIO-stiften via webbgränssnittet.

Nästa steg

Nu vet du hur du kan använda GPIO-stiften med hjälp av bryggkablar. Naturligtvis finns det också externa Pythonmoduler och C-bibliotek för att styra GPIO-stiften. Ett bra nästa steg skulle vara att utöka ett av kodexemplen. Till exempel genom att använda ytterligare lysdioder eller en knapp.
Ha kul med att experimentera!

Lämna en kommentar