Tu Raspberry Pi puede controlar dispositivos externos usando sus GPIO. Aquí te enseñamos cómo.
Los GPIO
La diferencia más grande entre una Raspberry Pi y otras computadoras es la presencia de sus pines GPIO – General Purpose Input Output. Esos pines que se ven a un lado de la placa son conectores de uso general que pueden servir para enviar o recibir señales de módulos electrónicos externos. Pueden servir para conectarse a sensores de todo tipo, y para controlar motores, luces y cualquier otro dispositivo electrónico que pueda usar señales digitales. Funcionan a 3.3 Voltios (cuidado al interconectar tu Raspberry Pi con otros dispositivos que usen otros voltajes) y se pueden controlar desde muchos lenguajes de programación.
Los GPIO de tu Raspberry Pi tienen diferentes funciones, pero la que nos interesa ahora es la de funcionar como una salida.
LED
Un LED es un componente electrónico capaz de conducir la corriente eléctrica en un solo sentido. Cuando lo hace, emite luz. Por eso su nombre: Light Emitting Diode, LED o Diodo Emisor de Luz.
Un LED tiene 2 conectores, a modo de “patitas”. La “patita” larga o “ánodo” debe ir siempre conectada al lado positivo del circuito. La patita corta o “cátodo” debe ir conectada a la “tierra” o “ground” del circuito.
Un LED suele ser algo delicado. Si se le conecta directamente a una fuente de voltaje es probable que no resista la intensidad de la corriente y se queme. Para controlar el flujo de electrones que ingresa al LED deberemos usar un componente conocido como “resistencia”. Las resistencias que usaremos en este proyecto son fáciles de conseguir en tiendas de electrónica y. son sumamente económicas. El valor que necesitamos es de 330 Ohm.
El circuito
Vamos a conectarla resistencia y el LED a la Raspberry Pi. Usemos la imagen siguiente para guiarnos.
¡CUIDADO!
Una mala conexión puede causar daños irreparables a tu Raspberry Pi. Recomendamos siempre hacer las conexiones y desconexiones con la Raspberry apagada, y sólo encenderla luego de haber verificado que todo está conectado exactamente como se indica en las imágenes.
Usaremos un cable “de patch” tipo “hembra-hembra” para conectar el pin 6 (Ground) de la Raspberry Pi a la patita corta (cátodo) del LED. Usando otro cable conectamos el ánodo del LED a la resistencia de 330 Ohm. Finalmente usaremos un tercer cable para conectar el otro extremo de la resistencia al pín 11 de la Raspberry Pi, el pin cuyo nombre “oficial” es el GPIO17.
Podemos usar algo de cinta adhesiva para fijar nuestro circuito a la mesa y evitar que se desconecte.
Listo. Ahora necesitaremos algo de código para controlar el LED.
El programa
Raspbian viene con una variedad de editores de código. Usaremos Mu, un editor que nos permitirá escribir código en Python, un lenguaje de programación muy popular. Podemos encontrar Mu en el menú principal de Raspbian, en la sección “Programación”.
Al ejecutar Mu por primera vez aparecerá una pantalla en donde podremos elegir el modo en el que queremos trabajar. Simplemente seleccionemos “Python 3” y démosle click al botón “Ok” para continuar.
A continuación aparecerá el editor de código de Mu.
Aún no vamos a escribir un programa completo. Lo que haremos será usar el “REPL”, el editor que nos permite escribir código y ver sus resultados en tiempo real. Para abrir el REPL simplemente presionamos el botón REPL en la parte superior de la ventana de Mu.
Se abrirá en la parte inferior del editor una sub zona con una serie de mensajes, un prompt con el mensaje “In [1]: ” y un cursor listo para que escribamos algo de código.
Escribamos lo siguiente para indicarle a Python que queremos usar la biblioteca gpiozero y que nuestro LED está conectado al GPIO 17:
In [1]: from gpiozero import LED In [2]: luz = LED (17)
Luego, usemos la siguiente línea para encender el LED:
In [3]: luz.on()
Y para apagarlo, podemos escribir:
In [4]: luz.off()
El LED debería haberse encendido y luego apagado. ¡Felicitaciones, hemos creado nuestro primero proyecto de computación física!
Un mejor circuito
Unir los cables punto a punto está bien para un experimento rápido, pero no es lo más apropiado para circuitos más complejos. Para que nuestras conexiones sean más ordenadas vamos a usar un protoboard.
El protoboard tiene una serie de agujeros en los que podemos insertar los terminales de nuestros componentes electrónicos. Internamente los agujeros están conectados entre si, lo que permite la conexión entre las diferentes partes del circuito sin necesidad de usar cables.
En las siguientes imágenes se muestra nuestro nuevo circuito. Veamos que aun necesitamos cables para conectar el circuito a nuestra Raspberry Pi (esta vez del tipo macho-hembra), pero los componentes (LED y resistencia) ya no tienen cables entre sí. Estos se están conectando a través de las pistas internas del protoboard.
Coloquemos nuestros componentes siguiendo el nuevo circuito (de preferencia con la Raspbery Pi apagada).
Los mismos pasos que seguimos antes en el REPL de Mu deberían funcionar con este nuevo circuito. Pero vamos a probar algo más – usaremos el editor de Mu, un bucle “while” y la biblioteca “sleep” para hacer que el LED titile.
- Usemos el botón “Nuevo” para crear un editor de código vacío.
- Luego usemos el botón “Guardar” para darle nombre a nuestro programa. Guardémoslo con el nombre “luz.py”
- Ahora escribamos el siguiente código en el nuevo block:
from gpiozero import LED from time import sleep luz = LED (17) while True: luz.on() sleep(0.2) luz.off() sleep(0.2)
(Los espacios en las últimas 4 líneas se hacen usando la tecla TAB del teclado de la computadora).
Usemos el botón “Ejecutar” y deberíamos ver que nuestro LED titila.
Una vez que salgamos del trance inducido por mirar el LED podemos detener el programa usando el botón “Detener” de Mu. Luego podemos modificar el código y ver los resultados. El cambio obvio estará en el número que colocamos en los paréntesis de “sleep”. Poniendo un número mayor la pausa entre encendido y apagado del LED será mayor. Poniendo un número más pequeño… bueno, se entiende la idea.
¡Más! ¡Quiero más!
La Raspberry Pi tiene muchos GPIO. ¿Será posible usar 2 o 3 al mismo tiempo para controlar varios LEDs?
Claro que si. Modifiquemos el circuito para que se vea como en las imágenes siguientes (recordemos hacerlo con la Raspbery Pi apagada, y verificar que todo esté bien antes de volver a encenderla):
Ahora necesitamos que nuestro código acceda a los nuevos GPIO que estamos usando. Tal como hicimos antes:
- Usemos el botón “Nuevo” para crear un editor de código vacío.
- Luego usemos el botón “Guardar” para darle nombre a nuestro programa. Guardémoslo con el nombre “luz3.py”
- Ahora escribamos el siguiente código en el nuevo block:
from gpiozero import LED
from time import sleep
luz1 = LED (22)
luz2 = LED (27)
luz3 = LED (17)
while True:
luz1.on()
luz2.on()
luz3.on()
sleep(0.5)
luz1.off()
luz2.off()
luz3.off()
sleep(0.5)
Recuerda: Los espacios en las últimas líneas se hacen usando la tecla TAB del teclado de la computadora.
Usemos el botón “Ejecutar” y disfrutemos el show.
La secuencia de luces que mostramos al inicio del artículo se basa en la misma idea, pero es algo un poco más larga. El código es el siguiente:
from gpiozero import LED
from time import sleep
luz1 = LED (22)
luz2 = LED (27)
luz3 = LED (17)
while True:
luz1.on()
sleep(0.2)
luz1.off()
luz2.on()
sleep(0.2)
luz2.off()
luz3.on()
sleep(0.2)
luz3.off()
Básicamente encendemos una luz, pausamos, luego apagamos la luz anterior y encendemos la siguiente, volvemos a pausar y repetimos cuantas veces sea necesario.
¡Y ya está! Hemos visto cómo una Raspberry Pi puede controlar componentes electrónicos externos a través de sus GPIO y con unas cuantas líneas de código…
¿Alguien se anima a crear el juego de luces que tenía ESE auto de ESA serie de los 80s?
via GIPHY - Esto me trae recuerdos.... y me da algunas ideas