Guía de GPIO para principiantes

En esta entrada del blog aprenderás todo sobre los pines GPIO de la Raspberry Pi. Este post es especialmente para los novatos en electrónica.

En primer lugar, una advertencia
La Raspberry Pi puede sufrir daños irreparables si se utilizan los pines de forma incorrecta. Así que asegúrate siempre de que tu circuito es correcto y de que utilizas suficientes resistencias.

Qué son los pines GPIO

Los pines GPIO son los 40 pequeños pines de metal en la parte superior de la Raspberry Pi. La abreviatura GPIO significa entrada-salida de propósito general. Esto significa que los pines GPIO pueden utilizarse como interfaz para casi cualquier dispositivo electrónico.

Debido a la gran cantidad de formas de (mal) uso de los pines, empezar puede ser un poco confuso. Por lo tanto, esta entrada del blog proporciona algunos ejemplos sobre cómo controlar los pines utilizando Bash, C y Python. Así que un poco de experiencia en programación es una ventaja.

Aunque los 40 pines parecen idénticos, tienen diferentes funciones. 26 pines se pueden utilizar para GPIO y algunos tienen funciones adicionales. Otros 4 pines se utilizan como fuente de alimentación (POWER, dos veces 3V3 y dos veces 5V) y 8 como polo negativo (también tierra o GROUND). Los dos pines restantes son la interfaz I2C para la EEPROM de identificación.

Pinout

El siguiente gráfico muestra la información más importante, entre otras cosas el pinout. El pinout es idéntico para la mayoría de los modelos de Raspberry Pi, pero hay diferencias. Comprueba siempre el pinout exacto de tu modelo antes de conectar un dispositivo. Para ello sólo tienes que abrir un terminal en tu Raspberry Pi (Ctrl+Alt+t) y ejecutar el siguiente comando.

pinout

Verás un gráfico de todas las conexiones y el pinout exacto de tu Raspberry Pi.

Pinout de Raspberry Pi

Habrás notado que los números GPIO aparecen de forma aleatoria y no coinciden con la numeración de los pines. Para evitar confusiones, me refiero a la numeración del 1 al 40 como el número de BOARD y el número del 1 al 26 como el número de BCM o GPIO.

Así que el pin 1 del BOARD es el conector 3V3 POWER y el pin 2 del GPIO es el pin que está al lado con el número 3 del BOARD.

Cómo conectar un dispositivo a las clavijas

Hay varias alternativas para conectar un dispositivo a los pines GPIO. Algunos dispositivos tienen una cabecera GPIO para que el dispositivo pueda conectarse directamente a los pines GPIO. Sin embargo, por lo general, este no es el caso, por lo que se utilizan cables de puente o cables de extensión GPIO.

Ver nuestro Video ¡sobre los Pines GPIO!

En el siguiente ejemplo, se conecta un LED a la Raspberry Pi mediante cables de puente.

El circuito

Los cables de puente hembra a macho conectan el pin GPIO a un cabezal o a una protoboard. El pin debe entonces ser programado para operar el dispositivo. El dispositivo puede ser un botón, un LED, un sensor, un motor o una pantalla. Sólo es importante que el dispositivo pueda funcionar con 5 voltios o menos y que sea compatible con las interfaces I2C, SPI o UART

Para la construcción necesitamos el siguiente equipo.

  • Raspberry Pi con Raspberry Pi OS
  • Dos cables de puente macho a hembra
  • Un cable de puente macho a macho
  • Resistencia de 10 kilo Ohmios
  • LED
  • Placa de pruebas sin soldaduras

Conecte el pin 13 de GPIO (número de BOARD 33) al + tira y la clavija de TIERRA que se encuentra al lado (número de tablero 34) a la - tira de la protoboard. A continuación, conecte un extremo de la resistencia de 10 kilo ohmios (cualquier resistencia) en el + tira y el otro extremo en una de las tiras transversales. Para el LED, la orientación es crucial. El ánodo es el más largo de los dos brazos y suele estar doblado, el cátodo es el brazo más corto. El ánodo debe apuntar siempre hacia el + dirección, es decir, hacia la fuente de energía, y el cátodo en el dirección, es decir, hacia TIERRA. Por lo tanto, coloque el brazo más largo en la misma banda transversal que la resistencia, de modo que el brazo más corto esté en la banda transversal adyacente. Por último, utilice el cable de puente macho-macho para conectar la banda transversal del cátodo (brazo más corto del LED) a la - tira.

El siguiente diagrama muestra el ensamblaje, asegúrese de que todo está correcto y que los componentes están insertados en la placa hasta el final, de lo contrario habrá contactos sueltos.

Aufbau des Schaltkreises

Los siguientes tres ejemplos de código en Bash, Python y C se basan en esta estructura. Si utiliza otros pines, deberá modificar el código en consecuencia.

Bash

Controlar los pines GPIO a través de Bash es muy fácil. En Linux, los pines GPIO son controlados por los archivos en el /sys/class/gpio carpeta. Para utilizar un pin GPIO, primero hay que exportarlo. Como ejemplo utilizo el pin GPIO 13. En lo que sigue los nombres de los archivos están en negrita y cursiva.

Abra un terminal y liste el contenido de la carpeta gpio.

cd /sys/class/gpio
ls

La carpeta contiene los archivos exportados y no exportados, así como subcarpetas para cada pin GPIO exportado.

Exportamos el pin escribiendo el número de GPIO en el /sys/class/gpio/export archivo. Ejecute este comando en el terminal.

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

Ahora se ha creado una carpeta con el número de pin correspondiente gpio13. Esta carpeta contiene otras carpetas y archivos. Por el momento, sólo los archivos de dirección y valor son importantes para nosotros.

El dirección guarda el modo de la clavija:

en -> El pin está en modo de lectura o de entrada

fuera -> El pin está en modo de escritura o de salida

El valor almacena el estado de tensión del pin:

0 -> el pin está en modo LOW -> no se aplica tensión al pin

1 -> El pin está en modo HIGH -> Se aplica tensión al pin

Los siguientes comandos establecen el modo fuera y el valor a 1.

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

El LED se enciende ahora. Es importante restablecer los valores de los pines después de su uso. Los siguientes comandos deben ser ejecutados después de cada uso.

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

Programa en Python

Ahora abstraemos y automatizamos estos comandos Bash en Python.

El siguiente script de Python proporciona un sencillo GPIO_Pin clase. Esto hace que sea extremadamente fácil de usar. La página web os nos permite ejecutar los mismos comandos bash que los anteriores desde Python. además, utilizando el módulo __del__ ya no es necesario reiniciar y desinstalar manualmente los pines.

importar os
from time import sleep

clase GPIO_Pin:
    def __init__(self, num, mode):
        si 0 <= num o num  Introduce un número de 0 a 40')
        si mode == 'out' o mode == 'write':
            self.mode = 'out'
        elif mode == 'in' o mode == 'read':
            self.mode = 'in'
        si no:
            print('Modo de clavijas inválido -> Introduzca "out" o "write" para la salida, "in" o "read" para la entrada')
        si self.num y 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)}/dirección')

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

    def write(self, value):
        si valor == 0 o valor == 'LOW':
            os.system(f'echo 0 > /sys/class/gpio/gpio{str(self.num)}/valor')
        elif valor == 1 o valor == 'HIGH':
            os.system(f'echo 1 > /sys/class/gpio/gpio{str(self.num)}/value')
        si no:
            print('Valor no válido -> Introduzca 1 o "HIGH" para HIGH, 0 o "LOW" para 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)}/dirección')

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

if __name__ == '__main__':
    main()

Con el módulo de tiempo podemos incluso hacer que el LED parpadee sin ningún problema. Todo el script se puede extender a un módulo de Python para el control de GPIO.

Programa C

También en C podemos editar fácilmente el contenido de la carpeta gpio. Usando la biblioteca estándar stdlib podemos abrir archivos y cambiar su contenido.
El siguiente programa en C debe ser compilado antes de ser ejecutado. Crear un archivo gpio.c y copiar el programa en él.
A continuación, abra un terminal y navegue hasta la carpeta donde se encuentra el gpio.c se encuentra el archivo. Utilice los siguientes comandos para compilar y ejecutar el programa.

gcc -o gpio gpio.c
./gpio

Aquí está el programa.

#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("Fallo al abrir el archivo de exportación\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("Fallo al abrir el archivo unexport\n");
        exit(-1);
    }
    fprintf(unexport, "%d", num);
    fclose(unexport);
    return 0;
}

int set_direction(char *mode, int num) {
    char dirección_ruta_archivo[1024];
    snprintf(dirección_ruta_fichero, sizeof(dirección_ruta_fichero), "/sys/clase/gpio/gpio%d/dirección", num);
    FILE* dirección = fopen(dirección_ruta_fichero, "w");
    si (dirección == NULL) {
        printf("Fallo al abrir el archivo de dirección\n");
        exit(-1);
    }
    fputs(modo, dirección);
    fclose(direction);
    return 0;
}

int set_value(int val, int num) {
    char valor_ruta_archivo[1024];
    snprintf(valor_ruta_archivo, sizeof(valor_ruta_archivo), "/sys/class/gpio/gpio%d/valor", num);
    FILE* value = fopen(value_file_path, "w");
    si (valor == NULL) {
        printf("Fallo al abrir el archivo valor\n");
        exit(-1);
    }
    fprintf(valor, "%d", val);
    fclose(valor);
    return 0;
}

int main() {

    int rslt;
    int num
    int número_de_parpadeo;

    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 - Aplicación GPIO

La forma más fácil de controlar los pines GPIO es con la ayuda de la aplicación GPIO. La página web Interfaz web de PiCockpit es gratuito para hasta 5 Raspberry Pi. Ofrece dos grandes ventajas: No necesitas saber programación para controlar tus pines GPIO y puedes hacerlo desde cualquier lugar.

Sólo tienes que instalar el cliente PiCockpit en tu Raspberry Pi y conectarte a tu cuenta PiCockpit. Después de eso puedes controlar fácilmente los pines GPIO a través de la interfaz web.

Próximos pasos

Ahora ya sabes cómo utilizar los pines GPIO con la ayuda de los cables puente. Por supuesto, también hay módulos externos de Python y librerías de C para controlar los pines GPIO. Un buen paso siguiente sería ampliar uno de los ejemplos de código. Por ejemplo, utilizando LEDs adicionales o un botón.
¡Diviértete experimentando!

Deja un comentario