Todo sobre los GPIO Raspberry Pi

 

GPIO Raspberry Pi

Los pines GPIO de la Raspberry Pi son los grandes olvidados, pero que sabiendo como utilizarlos nos abre un mundo de posibilidades. De eso trata este artículo, de abrirte las puertas de este mundo e introducirte en la programación y presentarte las posibilidades de los GPIO. En próximos post también te enseñaremos a conectar Arduino y la Raspberry Pi mediante estos pines para conseguir grandes proyectos uniendo el poder de ambas plataformas.

Introducción a los GPIO y esquemas

GPIO (General Purpose Input/Output) es, como su propio nombre indica, un sistema de E/S (Entrada/Salida) de propósito general, es decir, una serie de conexiones que se pueden usar como entradas o salidas para usos múltiples. Estos pines están incluidos en todos los modelos de Raspberry Pi, para que puedas realizar proyectos interesantes como lo harías con Arduino.

Los GPIO representan la interfaz entre la Raspberry Pi y el mundo exterior. Y con ellos podrás hacer multitud de proyectos, desde hacer titilar un LED hasta otros mucho más sofisticados. Pero para eso debes saber sus características y como se programan. Lo primero variará en función de la revisión de placa que tengas o del modelo.

Todos los pines son de tipo “unbuffered”, es decir, no disponen de buffers de protección, así que deberás tener cuidado con las magnitudes (voltajes, intensidad,…) cuando conectes componentes a ellos para no dañar la placa. Como podrás apreciar en las imágenes posteriores, no todos los pines tienen la misma función:

  • Pines de alimentación: puedes apreciar pines de 5v, 3v3 (limitados a 50mA) y tierra (GND o Ground), que aportan alimentación a estos voltajes para tus circuitos. Te pueden servir como una fuente de alimentación, aunque también puedes utilizar otras fuentes (pilas, fuentes de alimentación externas, etc). Recuerda que son unbuffered y debes tener cuidado para no dañar la placa.
  • DNC (Do Not Connect): son pines que por el momento no tienen función, pero en futuras implementaciones son utilizados para otros fines. Por eso solo los vas a encontrar en modelos más primitivos de la Raspberry Pi. En las actuales placas han sido marcados como GND.
  • GPIO normales: son conexiones configurables que puedes programar para tus proyectos, tal como te enseñaremos más adelante.
  • GPIO especiales: dentro de éstos se encuentran algunos pines destinados a una interfaz UART, con conexiones TXD y RXD que sirven para comunicaciones en serie, como por ejemplo, conectar con una placa Arduino. También podemos ver otros como SDA, SCL, MOSI, MISO, SCLK, CE0, CE1, etc…, los cuales explicaremos su funcionamiento más adelante.

Esquemas de los GPIO según el modelo

Todas las placas y revisiones no disponen de esquemas GPIO iguales. Aquí te ofrecemos todos los esquemas de las diferentes placas que existen por el momento. En las siguientes imágenes podemos apreciar los distintos layouts de los modelos existentes por el momento:

Model B (Rev 1.0)

Layout GPIO Model B Rev1

Model A/B (Rev 2.0)

Layout GPIO Model A y B Rev2

Model A+, B+, y 2

Layout GPIO Model A+, B+ y 2

Como puedes comprobar, existen tres esquemas básicos. Los de la revisión 1.0 del modelo B, los incluidos en la revisión 2.0 del modelo A y B, y los modernos A+, B+ y 2 que comparten el mismo esquema de conexiones.

Introducción a los HATs y Plates

HAT para Raspberry Pi

Aunque dedicaremos otro post a realizar una mega comparativa de HATs (Hardware Attached on Top) y Plates para la Raspberry Pi, con ejemplos de sus usos, vamos a explicar qué son y qué tienen que ver con los GPIO. Si ya estás familiarizado con Arduino, es fácil captar la idea de lo que son estos componentes, puesto que en el mundillo Duino se conocen como Shields o módulos y Plates.

Los Plates son placas agujereadas para montar circuitos fácilmente. Algo así como una protoboard que puede ser conectado a los GPIO de la Raspberry Pi. Son un buen complemento si deseas montar dispositivos electrónicos de montaje superficial. Como ves, su función es idéntica a su equivalente para Arduino.

Raspberry Pi con HAT

En cambio, los HATs son similares a los shields o escudos de Arduino. Es decir, placas de expansión que se pueden conectar a los GPIO para agregar funcionalidades a la placa. Si te fijas en el nombre, coincide con la palabra inglesa “sombrero” y que hace referencia a la forma en que se conectan con la Raspi.

Al ser un complemento nuevo, éstos solo son compatible con los modelos de Raspberry Pi que comparten el mismo esquema de conexiones. Si recuerdas el apartado anterior, éstos son el A+, B+ y la nueva versión 2 de la placa SBC. Pero en el mercado podrás encontrar diferentes fabricantes que suministran este tipo de HATs para Raspberry Pi. Uno de ellos es AdaFruit, que vende tarjetas de expansión denominadas HatADay y que contienen pantallas TFT, GPS, servomecanismos, complementos para robótica, etc…

Introducción al uso de los GPIO

Conexión del LED a los GPIO de la Raspberry Pi
Al igual que Arduino emplea su entorno Arduino IDE para crear sketchs o códigos fuente para programar los proyectos, la Raspberry Pi permite también programar sus GPIO, pero con mayor flexibilidad. Se puede realizar desde tu distribución utilizando multitud de herramientas con diversos lenguajes de programación (Python, Java, C,…), o desde la consola utilizando sencillos scripts y comandos.

Por lo general, la Raspberry Pi utiliza distribuciones Linux. Como buen UNIX, el sistema operativo tratará a todos los elementos, incluido el hardware, como un fichero. Ya sabes que en Windows existen unidades (C:, D:,…) o dispositivos hardware. Pero en un *nix todo son ficheros, como por ejemplo el disco duro (/dev/sda), la unidad de DVD (/dev/dvd), tarjetas SD (/dev/mmcblk0), etc…

Pues bien, los puertos GPIO también serán tratados como un fichero más, aunque no se encuentren en el dierctorio /dev, y por tanto podrás emplear los comandos básicos de la consola para gestionar ficheros. Por ejemplo, si queremos controlar un LED, podríamos entrar en la consola (para nuestros ejemplos hemos empleado Raspbian) y escribir lo siguiente:


echo 17 > /sys/class/gpio/export

Con esta línea crearíamos un fichero con la estructura del GPIO correspondiente para que pueda ser manipulado. Luego se debería de configurar como entrada o salida, según lo que quieras. En nuestro caso como salida, puesto que queremos alimentar al LED para encenderlo:

echo out > /sys/class/gpio/gpio17/direction

Ahora se podría encender o apagar. Para ello le podemos dar valores a la salida que hemos creado. Si le damos valor 1 se encenderá y con valor 0 se apagará:

echo 1 > /sys/class/gpio/gpio17/value
echo 0 > /sys/class/gpio/gpio17/value

Una vez termines el experimento, puedes borrar la entrada para realizar otro ejercicio en el mismo pin o en otro diferente:

echo 17 > /sys/class/gpio/unexport

¿Simple verdad? Pues ahora puedes utilizar tu imaginación y utilizar otros comandos que normalmente utilizas con ficheros y directorios para gestionar los GPIO. Por ejemplo, puedes listar los GPIO que tienes activos con:

cd /sys/class/gpio
ls

También puedes crear scripts para Bash (o el intérprete que utilices). Por ejemplo, continuando con el ejemplo del LED, se puede crear un script que podamos ejecutar en cualquier momento sin tener que poner los comandos uno a uno. Para ello, abre un fichero de texto y escribe el siguiente contenido:

#!/bin/bash
source gpio
gpio mode 17 out
while true; do
gpio write 17 1
sleep 1.3
gpio write 17 0
sleep 1.3
done

Luego guarda el texto en un fichero denominado, por ejemplo, LED.sh y cuando lo desees abrir solo tendrás que situarte en el directorio donde lo hayas guardado y teclear lo siguiente esto para su ejecución:

./LED.sh

Si lo anterior no funciona, puede que debas darle permisos de ejecución al fichero LED.sh. Puedes realizarlo desde el entorno gráfico o con chmod (chmod u+rwx LED.sh). Y el resultado será un LED que titila cada 1.3 segundos. Recuerda que el límite es tu imaginación.

Programación avanzada de los GPIO

Lenguajes de programación

Pues se puede complicar algo más para realizar otros proyectos algo más sofisticados. Sobre todo si utilizamos lenguajes de programación para crear nuestros proyectos. Se pueden utilizar diferentes herramientas y lenguajes de programación. Por ejemplo, el lenguaje de programación C utilizando bibliotecas como WiringPi, pigpio, sysfs, etc…, o compilar nuestros propios códigos fuente con otros lenguajes como C#, Ruby, Java, Perl, BASIC y Python.

Y si no sabes programar, no te preocupes, hasta un niño puede programar los GPIO utilizando lenguajes gráficos como los que aporta Scratch, que se incluye en Raspbian por defecto, pero puedes instalarlo en otras distros sin problema y disfrutar del sistema “drag and drop” con bloques gráficos de Scratch.

C y wiringPi

Una de las mejores maneras de crear programas en lenguaje de programación C es utilizando la biblioteca wiringPI (si tu distro no la tiene instalada, lo primero que debes hacer es descargarla e instalarla, al igual que el compilador gcc u otro que prefieras). Yo utilizaré gcc y la librería wiringPI. Para crear nuestro código fuente debemos enlazar la biblioteca.

Si no los tienes instalados, instala GCC:

sudo apt-get install gcc

Y luego haz lo mismo para la biblioteca wiringPI:

sudo apt-get install git-core

sudo apt-get update

sudo apt-get upgrade

git clone git://git.drogon.net/wiringPi

cd wiringPi

git pull origin

cd wiringPi

./build

Si por ejemplo queremos seguir con nuestro ejemplo de LED que titila, y lo denominamos LED.c. En un editor de texto que prefieras, como por ejemplo gedit, puedes escribir el código fuente y luego guardarlo con el nombre que hemos elegido. El contenido de nuestro programa en C contendrá las siguientes líneas:

/*Código fuente para hacer titilar un LED desde los GPIO*/

#include <stdio.h>
#include <wiringPi.h>

int main (void)
{
printf (“Titilando LED\N”);
if (wiringPiSetup () == -1)
return 1;
pinMode (0, OUTPUT); //0 es el correspondiente del chip al pin 17
for (;;)
{
digitalWrite (0, 1); //Poner en ON o encenderlo
delay (1300); //Retraso de 1.3 segundos
digitalWrite (0, 0); //Poner en Off o apagar
delay (1300); //Retraso para volver a encender...
}
return 0;
}

Para compilarlo, desde el directorio donde se encuentra el código fuente guardado, podemos teclear lo siguiente:

gcc -o LED LED.c -lwiringPi

Si te has decidido por la librería pigpio, utiliza “-lpigpio”. Y para ejecutar el programa que hemos compilado, se hará de forma similar al script. Pero necesitaremos privilegios para iniciar la ejecución del binario llamado LED que hemos generado:

sudo ./LED

Python

Python es el lenguaje preferido para programar los GPIO. Las bibliotecas anteriormente citadas, también pueden ser empleadas con Python. Raspbian ya incluye un módulo denominado RPI.GPIO para poder crear scripts en Python, pero te recomiendo que utilices e instales pigpio, ya que éstos scripts pueden ser ejecutados tanto en Windows, Mac OS X como en Linux. Solo se necesitan los demonios corriendo en la máquina donde quieras ejecutar el código.

Instálalo así:

sudo apt-get install python-dev python-rpi.gpio

El código fuente para realizar el titileo de nuestro LED en Python es el siguiente (haz lo mismo que con el código C, puedes editarlo en un editor de texto):

#!/usr/bin/env python
#LED.py

import time
import pigpio
pi = pigpio.pi()

pi.set_mode (17, pigpio.OUTPUT) #Ponemos el pin 17 como salida

pi.set_servo_pulsewidth (17, 1300) #Iniciamos pulsos cada 1.3 segundos para encender el LED

pi.stop() #Terminamos el programa.

Lo debes guardar con el nombre LED y la extensión “.py” y para ejecutarlo, teclea en el terminal:

sudo pigpiod
./LED.py

Scratch y GPIO

Para usar Scratch con los GPIO podemos utilizar diferentes métodos, como con el resto de lenguajes de programación. Uno es emplear ScratchGPIO, RpiScratchIO, etc… Pero lo primero, si ya tienes Scratch y así será si estás utilizando Raspbian, es instalar el complemento ScratchGPIO:

sudo wget http://goo.gl/Pthh62 -O in stall_scratchgpio5.sh
sudo bash install_scratchgpio5.sh

Por ejemplo, si disponemos de ScratchGPIO, podemos crear el siguiente sketch para hacer titilar el LED:

Scratch sketch para titilar Led

BASIC

Si estás acostumbrado a programar en BASIC o ya eres usuario de placas de desarrollo de Parallax BASIC Stamp (que emplea PBASIC para programar los microcontroladores), te resultará más sencillo programar los pines GPIO en lenguaje BASIC.

Una de las posibilidades es usar RTB (Return to Basic), para instalarlo (en este caso es la versión 2.20):

cd /tmp
wget http://unicorn.drogon.net/rtb-2.20-1.deb
sudo dpkg -i rtb-2.20-1.deb
sudo apt-get -f install

Para ejecutarlo, solo tienes que teclear rtb en el terminal. Y con él teclear el siguiente código fuente renovado, aunque con reminiscencias del BASIC clásico y guardarlo como LED.rtb:

//Titilar LED

PinMode (17, 1) //Pin 17 como salida
CYCLE
DigitalWrite (17, 1) //Pin ON
WAIT (1.3) //Esperamos 1.3 segundos
DigtialWRite (17, 0) //Pin OFF
WAIT (1.3)
REPEAT
END

Espero que te haya servido de ayuda. Cualquier duda u opinión, deja tus comentarios!

El artículo Todo sobre los GPIO Raspberry Pi ha sido originalmente publicado en ComoHacer.eu | ¿Inventamos juntos?.

comohacer_eu