Menu mobile
En cuanto a lo que es directamente la placa Raspberry Pi, sabemos que está preparada para trabajar con programación física de componentes electrónicos mediante sus pines GPIO (general-purpose input/output). Estos pines de propósito general de entrada/salida son algunos de los que se pueden ver en dos filas de 20 pines. En la siguiente imagen podemos ver más claramente a que corresponde cada pin.
Cualquiera de los pines GPIO puede designarse (en el software) como un pin de entrada o salida y utilizarse para una amplia gama de propósitos, como conectar un LED o un sensor.
Nota: la numeración de los pines GPIO no está en orden numérico; Los pines GPIO 0 y 1 están presentes en la placa (pines físicos 27 y 28) pero están reservados para uso avanzado (ver más abajo).
Voltajes
Dos pines de 5V y dos pines de 3V3 (3,3V) están presentes en la placa, así como varios pines de tierra (GND: 0V), que no son configurables. Los pines restantes son todos pines 3V3 de uso general, lo que significa que las salidas están configuradas en 3V3 y las entradas son tolerantes a 3V3.
Salidas
Un pin GPIO designado como pin de salida se puede configurar en estado alto (3V3) o bajo (0V).
Entradas
Un pin GPIO designado como pin de entrada se puede leer como alto (3V3) o bajo (0V). Esto se hace más fácil con el uso de resistencias internas pull-up o pull-down. Los pines GPIO2 y GPIO3 tienen resistencias pull-up fijas, pero para otros pines esto se puede configurar en el software.
Más
Además de los dispositivos de entrada y salida simples, los pines GPIO se pueden usar con una variedad de funciones alternativas, algunas están disponibles en todos los pines, otras en pines específicos.
· PWM: Pines que admiten la Modulación de ancho de pulso, usada para transmitir información a través de un canal de comunicaciones o para controlar la cantidad de energía que se envía a una carga.
o Software PWM disponible en todos los pines
o Hardware PWM disponible en GPIO12, GPIO13, GPIO18, GPIO19
· SPI: El Bus SPI (del inglés Serial Peripheral Interface) es un estándar de comunicaciones, usado principalmente para la transferencia de información entre circuitos integrados en equipos electrónicos.
o SPI0: MOSI (GPIO10); MISO (GPIO9); SCLK (GPIO11); CE0 (GPIO8), CE1 (GPIO7)
o SPI1: MOSI (GPIO20); MISO (GPIO19); SCLK (GPIO21); CE0 (GPIO18); CE1 (GPIO17); CE2 (GPIO16)
· I2C: Circuito Integrado Interno (I²C, del inglés Inter-Integrated Circuit), se usa internamente para la comunicación entre diferentes partes de un circuito, por ejemplo, entre un controlador y circuitos periféricos integrados.
o Datos: (GPIO2); Reloj (GPIO3)
o Datos EEPROM: (GPIO0); Reloj EEPROM (GPIO1)
· Serie: Puertos para comunicación UART, en inglés de Universal Asynchronous Receiver-Transmitter, mediante pin de transmisión TX y pin de recepción RX.
o TX (GPIO14); RX (GPIO15)
Existen 2 formas de numerar los pines de la Raspberry Pi, en modo GPIO o en modo BCM. Esto es importante a la hora de programar. La diferencia entre estas notaciones generalmente lo notamos cuando estamos controlando los GPIO con python u otro lenguaje y tenemos que ingresar en qué modo usaremos los gpio en GPIO.BOARD o GPIO.BCM.
La opción GPIO.BOARD especifica que se está refiriendo a los pines por su número, es decir los números impresos en nuestra Raspberry Pi (por ejemplo P1), en la imagen siguiente te mostramos el pin 1 y el pin 2, para seguir numerando seria de izquierda a derecha, siendo el que está debajo del pin 1 el pin 3, toda esa fila serían los pines impares y la opuesta los pines pares.
La opción GPIO.BCM se refiere a los pines por su número de "Broadcom SOC channel", estos no son correlativos como en el modo BOARD, en la imagen siguiente se muestran tanto los pines en BOARD como en BCM de las distintas versiones de Raspberry Pi, siendo los BCM los que su nombre comienza con GPIO y los centrales los pines BOARD. Los BCM serían por así decirlo como la numeración del procesador y los BOARD del conector.
Para controlar GPIO con Python, primero debes importar una librería de código escrito previamente. El más común y difundido es el Rpi.GPIO, utilizado para crear miles de proyectos desde los primeros días de la RPi.
Otra librería interesante es WiringPi, que hace que los pins sean más “portables” de unos códigos a otros, más universales.
Para instalar la última versión ponemos las siguientes instrucciones en la consola:
cd /tmp
wget https://project-downloads.drogon.net/wiringpi-latest.deb
sudo dpkg -i wiringpi-latest.deb
Para ver estos pines en la Raspberry, podemos abrir la consola de comandos, y ejecutar el comando: gpio readall
Como su nombre indica, leerá todos lo que pertenezca a gpio, y nos mostrará la siguiente tabla informativa, donde se pueden ver cada pin y características.
Otro comando que nos puede interesar es: pinout. Con este nos mostrará información de manera más visual:
Ya sabemos lo que son estos pines, pero ahora vamos a explicar cómo usarlos y programar dispositivos. Se puede usar la misma consola de comandos para cambiar la configuración de los pines, por ejemplo, que el pin 21 saque voltaje alto para encender un LED que tenga conectado.
Esto se puede “programar” de varios modos y el más sencillo es usar simplemente comandos sobre la consola. Primero de todo conectaremos el LED a la RPi. Recuerda que siempre tiene que tener una resistencia en serie conectada, en nuestro caso usaremos una de 1k Ω y un LED rojo conectados al pin gpio21 del siguiente modo:
El pin 40 va a la resistencia, esta va al ánodo del LED, el cátodo del LED va a GND, en el pin 39.
A continuación, arrancamos la RPi y abrimos el terminal de comandos y ejecutamos el comando:
ls /sys/class/gpio/
El directorio /sys es uno de los muchos directorios virtuales de nuestro sistema. No lo encontraremos en la tarjeta SD. El sistema sólo "finge" que tal directorio existe, de hecho, todas las referencias a archivos en ese directorio son manejadas por el kernel (núcleo del SO en Linux). El directorio /sys permite acceder a información sobre los controladores del sistema Linux. En este caso, nos fijamos en los controladores de clase GPIO , es decir, los puertos de entrada y salida.
Como se puede ver, ya hay algunos archivos en este directorio:
De forma predeterminada, el acceso a los pines no es posible, por lo que debemos habilitarlo. Usaremos un archivo llamado export para este propósito. Escribir en este archivo hará que el kernel nos proporcione el pinout apropiado del procesador. Queremos tener acceso al pin GPIO21, así que escribimos el número 21 en el archivo /sys / class / gpio / export escribiendo:
echo 21 > /sys/class/gpio/export
Ahora podemos verificar el contenido del directorio / sys / class / gpio nuevamente; encontraremos un nuevo subdirectorio llamado gpio21. Su contenido te permitirá controlar el comportamiento del pin seleccionado.
De forma predeterminada, el pin exportado se establece en input ( in ). Queremos controlar un diodo, por lo que necesitamos una salida ( out ). Necesitamos cambiar la dirección del pin. Para ello, simplemente escribimos out en el fichero / sys / class / GPIO / gpio21 / direction:
echo out > /sys/class/gpio/gpio21/direction
De ahora en adelante, podemos controlar el diodo escribiendo los valores en el archivo de valores.
Para encender el diodo emitimos el comando:
echo 1 > /sys/class/gpio/gpio21/value
Por tanto, para apagarlo con 0:
echo 0 > /sys/class/gpio/gpio21/value
Cuando terminemos los experimentos, podemos limpiar, es decir, deshabilitar el acceso al pin GPIO21. Lo exportamos al principio, por lo que ahora necesitamos deshacer esta operación:
echo 21 > /sys/class/gpio/unexport
Como puedes ver en el mundo de Linux, todo es un archivo. El directorio /sys se comporta como archivos normales en la tarjeta SD. Podemos utilizar herramientas estándar de la consola o nuestros propios programas para controlar los dispositivos conectados. Curiosamente, ejecutar los ejemplos no requirió programación nuestra, son solo operaciones de archivo normales. Por supuesto, este no es un método eficaz, pero en muchos casos será suficiente.
Vale la pena mencionar que usando el acceso al directorio/sys/class/gpio también puede controlar los pines en otras plataformas. Esta funcionalidad la proporciona el kernel de Linux, no depende de la Raspberry Pi.
Ya hemos aprendido el método de comunicación directa con el kernel. Esta es una opción interesante, pero no muy efectiva y no necesariamente conveniente en algunos casos. Afortunadamente, la Raspberry Pi viene con algunas bibliotecas y programas bastante buenos que te permiten acceder a los pines de manera más eficiente. Uno de ellos es WiringPi.
En esta parte del curso no escribiremos programas (solo scripts simples), por lo que usaremos un programa llamado gpio - con él puede usar fácilmente líneas GPIO desde la consola.
Puede encontrar más información sobre el programa en la extensa documentación:
man gpio
Podemos ver en el apartado SYNOPSIS las diferentes opciones de comandos.
Para usar comandos con WiringPi, verificaremos primero la versión de esta librería instalada. Para hacer esto, ejecuta gpio -v . Si el número de versión es 2.46 o superior, entonces todo bien y puedes continuar. De ser inferior, usa estos comandos para instalar una versión superior, como hemos dicho anteriormente:
wget https://unicorn.drogon.net/wiringpi-2.46-1.deb
sudo dpkg -i wiringpi-2.46-1.deb
Ahora vamos con un sencillo ejemplo de encendido de un LED con el mismo conexionado que el ejemplo anterior, pero esta vez en el pin 12 (Modo BCM), que es nuestro pin físico 32 en el conector.
Como se mencionó, la biblioteca WiringPi usa una numeración de pines diferente. Sin embargo, puede forzar el uso de los mismos números que para el directorio / sys . Quedémonos con esta numeración ahora.
Para empezar, configuramos el pin 12 como salida emitiendo el comando:
gpio -g mode 12 out
La opción -g de gpio nos hace usar la numeración de pines de la CPU.
Ahora podemos apagar y encender el LED escribiendo después del número de pin su estado, 0 lógico o 1 lógico respectivamente:
gpio -g write 12 0
gpio -g write 12 1
Obtuvimos la misma funcionalidad que antes, pero no tuvimos que hacer referencia a los archivos directamente, lo que hizo que todo el "código" fuera más corto.
WiringPi
Por supuesto, para la prueba podemos intentar usar la numeración de la biblioteca WiringPi. Volvemos a la tabla con pines ( gpio readall ) y buscamos nuestro pin número 12. Según la numeración interna de la biblioteca, tendrá el número 26.
Entonces podemos emitir comandos:
gpio mode 26 out
gpio write 26 0
gpio write 26 1
Podemos comprobar como el funcionamiento será idéntico.
Ya podemos controlar salidas universales. Sin embargo, el método de emitir comandos manualmente no es muy conveniente. Afortunadamente, no tenemos que escribir manualmente todos los comandos en la terminal.
Podemos escribir scripts que se ejecutarán como "programas simples".
Un script es simplemente un archivo de texto que contiene los comandos que normalmente ingresamos desde el teclado en una ventana de terminal. Gracias a colocarlos en el archivo, no tenemos que volver a escribir todo, simplemente llame al archivo correspondiente.
Comenzaremos con el mismo ejemplo extremadamente simple, el encendido de un LED. Haremos que nuestro primer script configure el pin apropiado como salida y lo ponga alto (es decir, encienda el LED). Por supuesto, no tiene mucho sentido hacer un “programa” para algo tan simple, pero con esto practicaremos la creación y ejecución del script en sí.
Primero, necesitamos crear un nuevo archivo con la extensión “sh.” Por ejemplo, puede ser led.sh, para ello usaremos el editor nano:
nano led.sh
En su contenido, ingresamos los comandos que normalmente ingresaríamos en la consola, tenemos que precederlos con una sola línea: #!/Bin/sh. Entonces, el script que enciende el diodo conectado al pin 21 se vería así:
#!/bin/sh
gpio -g mode 21 out
gpio -g write 21 1
Guarde el archivo ( CTRL + X ). A continuación, debemos otorgarle a nuestro script los permisos adecuados para ser tratado como un "programa". Para esto usamos chmod :
sudo chmod +x led.sh
Para ejecutar el script, emitimos el comando:
./led.sh
Ahora el LED se encenderá sin más. Para apagarlo se necesitaría otro script distinto, que puedes probar por ti mismo. Vamos a poner ahora otro ejemplo más funcional, hacer que el led parpadee por sí solo. Creamos un nuevo archivo blink.sh :
nano blink.sh
En su contenido pegamos un bucle while simple (de momento no nos centraremos en la sintaxis):
while true
do
sleep 1
gpio -g write 21 0
done
Un bucle while, como su traducción indica, consiste en que algo se repita mientras algo se mantenga. En este caso, en modo breve, podemos ver que mientras sea “true” haga (do) las líneas siguientes. Por lo que se ejecturá en bucle lo que haya entre el “do” y el “done”.
El código anterior configura el pin número 21 como salida. Luego cambia de estado cada segundo (sleep 1). Guarde el archivo ( CTRL + X ), dale los permisos adecuados ( sudo chmod + x blink.sh ). La secuencia de comandos puede ser interrumpida por CTRL + C .
Ahora podrás ver como el LED parpadea cada segundo cuando lo ejecutemos.
Basándose en los ejemplos descritos aquí, ya tienes conocimientos para poder crear, por ejemplo, una simulación de semáforos simples.