Guida GPIO per principianti

In questo post del blog imparerete tutto sui pin GPIO del Raspberry Pi. Questo post è specialmente per i neofiti dell'elettronica.

Prima di tutto un avvertimento
Il Raspberry Pi può essere irreparabilmente danneggiato se i pin sono usati in modo scorretto. Quindi assicuratevi sempre che il vostro circuito sia corretto e che usiate abbastanza resistenze.

Cosa sono i pin GPIO

I pin GPIO sono i 40 piccoli pin di metallo sulla parte superiore del Raspberry Pi. L'abbreviazione GPIO sta per general purpose input output. Questo significa che i pin GPIO possono essere utilizzati come interfaccia per quasi tutti i dispositivi elettronici.

A causa del gran numero di modi di (mis)usare i pin, iniziare può essere un po' confuso. Pertanto, questo post del blog fornisce alcuni esempi su come controllare i pin usando Bash, C e Python. Quindi un po' di esperienza nella programmazione è un vantaggio.

Anche se i 40 pin sembrano identici, hanno funzioni diverse. 26 pin possono essere utilizzati per GPIO e alcuni hanno funzioni aggiuntive. Altri 4 pin sono usati come fonte di alimentazione (POWER, due volte 3V3 e due volte 5V) e 8 come polo negativo (anche terra o GROUND). I due pin rimanenti sono l'interfaccia I2C per l'ID EEPROM.

Pinout

Il grafico qui sotto mostra le informazioni più importanti, tra le altre cose il pinout. La piedinatura è identica per la maggior parte dei modelli di Raspberry Pi, ma ci sono differenze. Controllate sempre l'esatta piedinatura del vostro modello prima di collegare un dispositivo. Per questo devi solo aprire un terminale sul tuo Raspberry Pi (Ctrl+Alt+t) ed eseguire il seguente comando.

pinout

Vedrete un grafico di tutte le connessioni e l'esatta piedinatura del vostro Raspberry Pi.

Pinout di Raspberry Pi

Avrete notato che i numeri GPIO appaiono in modo casuale e non corrispondono alla numerazione dei pin. Per evitare confusione, mi riferisco alla numerazione da 1 a 40 come il numero BOARD e il numero da 1 a 26 come il numero BCM o GPIO.

Quindi il pin 1 della BOARD è il connettore 3V3 POWER e il pin 2 del GPIO è il pin accanto con il numero 3 della BOARD.

Come collegare un dispositivo ai pin

Ci sono diverse alternative per collegare un dispositivo ai pin GPIO. Alcuni dispositivi hanno un header GPIO in modo che il dispositivo possa essere collegato direttamente ai pin GPIO. Generalmente, però, questo non è il caso, ed è per questo che si usano fili di ponticello o cavi di estensione GPIO.

Guarda il nostro video sui pin GPIO!

Nell'esempio seguente, un LED è collegato al Raspberry Pi usando cavi jumper.

Il circuito

Il ponticello femmina-maschio collega il pin GPIO a un header o a una breadboard. Il pin deve poi essere programmato per far funzionare il dispositivo. Il dispositivo può essere un pulsante, un LED, un sensore, un motore o un display. È importante solo che il dispositivo possa funzionare con 5 volt o meno e che sia compatibile con le interfacce I2C, SPI o UART

Per la costruzione abbiamo bisogno delle seguenti attrezzature.

  • Raspberry Pi con Raspberry Pi OS
  • Due fili di collegamento da maschio a femmina
  • Un cavo di collegamento maschio-maschio
  • Resistenza da 10 kilo Ohm
  • LED
  • Bordo di pane senza saldature

Collegare il pin 13 di GPIO (numero 33 della scheda) al + striscia e il pin GROUND accanto ad esso (BOARD numero 34) al - striscia della breadboard. Poi inserite un'estremità della resistenza da 10 kilo Ohm (qualsiasi resistenza) nella + striscia e l'altra estremità in una delle strisce trasversali. Per il LED, l'orientamento è cruciale. L'anodo è il più lungo dei due bracci e spesso piegato, il catodo è il braccio più corto. L'anodo deve sempre puntare nel + direzione, cioè verso la fonte di alimentazione, e il catodo nel direzione, cioè verso la MASSA. Quindi mettete il braccio più lungo nella stessa striscia trasversale della resistenza, in modo che il braccio più corto sia nella striscia trasversale adiacente. Infine, usate il cavo jumper maschio-maschio per collegare la striscia trasversale del catodo (braccio più corto del LED) al - striscia.

Lo schema seguente mostra il montaggio, assicuratevi che tutto sia corretto e che i componenti siano inseriti nella scheda fino a dove possono andare, altrimenti ci saranno contatti allentati.

Aufbau des Schaltkreises

I seguenti tre esempi di codice in Bash, Python e C sono basati su questa struttura. Se usate altri pin, dovete modificare il codice di conseguenza.

Bash

Controllare i pin GPIO tramite Bash è molto facile. In Linux, i pin GPIO sono controllati dai file nella cartella /sys/class/gpio cartella. Per utilizzare un pin GPIO, deve prima essere esportato. Come esempio uso il pin 13 di GPIO. Di seguito i nomi dei file sono in grassetto e in corsivo.

Aprite un terminale ed elencate il contenuto della cartella gpio.

cd /sys/class/gpio
ls

La cartella contiene i file export e unexport e le sottocartelle per ogni pin GPIO esportato.

Esportiamo il pin scrivendo il numero GPIO nel file /sys/class/gpio/export file. Eseguite questo comando nel terminale.

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

Ora è stata creata una cartella con il numero di pin corrispondente gpio13. Questa cartella contiene altre cartelle e file. Per il momento, solo i file di direzione e di valore sono importanti per noi.

Il direzione salva la modalità del pin:

in -> Il pin è in modalità lettura o ingresso

fuori -> Il pin è in modalità di scrittura o di uscita

Il valore memorizza lo stato di tensione del pin:

0 -> il pin è in modalità LOW -> nessuna tensione è applicata al pin

1 -> Il pin è in modalità HIGH -> La tensione è applicata al pin

I seguenti comandi impostano la modalità su fuori e il valore a 1.

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

Il LED è ora acceso. È importante resettare i valori dei pin dopo l'uso. I seguenti comandi dovrebbero essere eseguiti dopo ogni uso.

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

Programma Python

Ora astraiamo e automatizziamo questi comandi Bash in Python.

Il seguente script Python fornisce un semplice GPIO_Pin classe. Questo lo rende estremamente facile da usare. Il sito os ci permette di eseguire gli stessi comandi bash di cui sopra da Python. inoltre, utilizzando il modulo {\an8}Delta non abbiamo più bisogno di resettare e riesportare manualmente i pin.

importare os
da time importare sleep

classe GPIO_Pin:
    def __init__(self, num, mode):
        se 0 <= num o num  Inserire un numero da 0 a 40')
        if mode == 'out' o mode == 'write':
            self.mode = 'out'
        elif mode == 'in' o mode == 'read':
            self.mode = 'in'
        else:
            print('Invalid Pin Mode -> Inserire "out" o "write" per l'output, "in" o "read" per l'input')
        se self.num e self.mode:
            os.system(f'echo {str(self.num)} > /sys/class/gpio/export')
            dormire(0.05)
            os.system(f'echo {self.mode} > /sys/class/gpio/gpio{str(self.num)}/direzione')

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

    def write(self, value):
        se valore == 0 o valore == 'LOW':
            os.system(f'echo 0 > /sys/class/gpio/gpio{str(self.num)}/valore')
        elif value == 1 o value == 'HIGH':
            os.system(f'echo 1 > /sys/class/gpio/gpio{str(self.num)}/value')
        else:
            print('Valore non valido -> Inserire 1 o "HIGH" per HIGH, 0 o "LOW" per 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)}/direzione')

def main():
    pin = GPIO_Pin(13, 'out')
    numero_di_blink = 10
    per i in range(numero_di_blink):
        pin.write('HIGH')
        dormire(0.5)
        pin.write('LOW')
        dormire(0.5)

if __name__ == '__main__':
    main()

Con il modulo del tempo possiamo anche far lampeggiare il LED senza alcun problema. L'intero script può essere esteso a un modulo Python per il controllo GPIO.

Programma C

Anche in C possiamo facilmente modificare il contenuto della cartella gpio. Usando la libreria standard stdlib possiamo aprire i file e cambiarne il contenuto.
Il seguente programma C deve essere compilato prima di poter essere eseguito. Creare un file gpio.c e copiarvi il programma.
Poi aprite un terminale e navigate fino alla cartella dove si trova il file gpio.c si trova. Usate i seguenti comandi per compilare ed eseguire il programma.

gcc -o gpio gpio.c
./gpio

Ecco il programma.

#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");
    se (export == NULL) {
        printf("Failed to open the export file\n");
        exit(-1);
    }
    fprintf(export, "%d", num);
    fclose(export);
    ritorna 0;
}

int unexport_pin(int num) {
    FILE* unexport = fopen(UNEXPORT, "w");
    se (unexport == NULL) {
        printf("Failed to open the unexport file\n");
        exit(-1);
    }
    fprintf(unexport, "%d", num);
    fclose(unexport);
    ritorna 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");
    se (direction == NULL) {
        printf("Failed to open the direction file\n");
        exit(-1);
    }
    fputs(mode, direction);
    fclose(direction);
    ritorna 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");
    se (value == NULL) {
        printf("Failed to open the value file\n");
        exit(-1);
    }
    fprintf(value, "%d", val);
    fclose(value);
    ritorna 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);

    ritorna EXIT_SUCCESS;
}

PiCockpit - App GPIO

Il modo più semplice per controllare i pin GPIO è con l'aiuto della GPIO App. Il Interfaccia web di PiCockpit è gratuito per un massimo di 5 Raspberry Pi. Offre due grandi vantaggi: Non è necessario conoscere la programmazione per controllare i pin GPIO e lo si può fare da qualsiasi luogo.

Basta installare il client PiCockpit sul tuo Raspberry Pi e connettersi al tuo account PiCockpit. Dopo di che puoi facilmente controllare i pin GPIO tramite l'interfaccia web.

Passi successivi

Ora sapete come utilizzare i pin GPIO con l'aiuto di fili di collegamento. Naturalmente ci sono anche moduli esterni Python e librerie C per controllare i pin GPIO. Un buon passo successivo sarebbe quello di estendere uno degli esempi di codice. Per esempio utilizzando ulteriori LED o un pulsante.
Divertiti a sperimentare!

Lascia un commento