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 al gran número de formas de (mal)usar los pines, empezar puede ser un poco confuso. Por lo tanto, esta entrada de 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.
pinoutVerás un gráfico de todas las conexiones y el pinout exacto de tu 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.
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
lsLa 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
lsAhora 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/valueEl 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/unexportPrograma 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.
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()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
./gpioAquí está el programa.
#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 - 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 cables puente. Por supuesto, también hay módulos Python externos y librerías C para controlar los pines GPIO. Un buen siguiente paso sería extender uno de los ejemplos de código. Por ejemplo utilizando LEDs adicionales o un botón.
¡Diviértete experimentando!