Cómo hacer LEDs parpadeantes con la Raspberry Pi

La Raspberry Pi es más que solo una computadora pequeña. Es una placa poderosa que te permite hacer muchas cosas con sus pines GPIO. Aquí te mostramos cómo hacer LEDs parpadeantes con la Raspberry Pi.

Tabla de Contenidos

• ¿Qué hace que los LEDs parpadeen?
• Lo que necesitas
• Cómo hacer LEDs parpadeantes
• Cómo funciona el código
• ¡Hagamos parpadear más LEDs!
• Preguntas Frecuentes

También lee: Cómo controlar tu Raspberry Pi a través de Windows via SSH

¿Qué hace que los LEDs parpadeen?

Cuando miras la parte superior de tu Raspberry Pi, encontrarás alrededor de 40 pines metálicos sobresaliendo de la placa de circuito. Si tienes una Raspberry Zero, probablemente haya agujeros circulares para soldar pines de encabezado. En cualquier caso, se llaman pines GPIO (Entrada / Salida de Propósito General).

Cada pin GPIO está diseñado para tener uno de dos modos en cualquier momento dado: un ALTO y un BAJO. Para las especificaciones de pinout de la Raspberry Pi, un pin cargado a 3.3 V cuenta como un ALTO o un “1 lógico”, mientras que cualquier cosa por debajo de alrededor de 2.5 V cuenta como un BAJO o “0 lógico”. Se dice que una placa que se basa en 3.3 V para salidas altas y bajas está en “lógica de 3.3v”.

Cuando conectas un LED entre un pin en ALTO y un pin GND, básicamente estás haciendo un circuito completo. El LED debería encenderse debido a la electricidad que pasa.

A veces, tus LEDs se quemarán si hay demasiada corriente pasando a través de ellos. Para evitar que eso suceda, puedes agregar una resistencia. No importa si está en el lado del ánodo o del cátodo; cualquiera de los lados debería disminuir la corriente que pasa.

También lee: Cómo programar un Arduino con una Raspberry Pi

GPIO y otros pines

Seamos claros aquí, ya que no todos esos pines metálicos se consideran GPIO. Solo son GPIO si pueden ser programados para tener un alto o bajo; de ahí el término “Entrada / Salida”. Para la Raspberry PI, también hay pines hechos para alimentación (3.3v, 5v y GND) y para trabajar con EEPROM (ID_SD y ID_SC).

Esta vez, no necesitarás pensar en todos esos otros pines excepto GND y un pin GPIO.

Programando los pines GPIO

¿Cómo le dices a cada pin GPIO qué hacer? A un nivel básico, tendrás que hacer comandos en código máquina. Eso va a ser un poco demasiado difícil para los principiantes.

En su lugar, para la Raspberry Pi, puedes usar Python o C++, que luego se compila en código máquina.

Para este proyecto en particular, estamos usando Python, ya que es más fácil de usar.

También lee: Cómo instalar Windows 11 en una Raspberry Pi 4

Lo que necesitas

• Cualquier modelo de Raspberry Pi que no sea el Pico (preferiblemente la Raspberry Pi 3 Modelo B+ como la del ejemplo, pero cualquier cosa funciona), instalado con el sistema operativo Raspberry Pi.
• Un monitor y cable HDMI
• Ratón y teclado
• Un cargador de teléfono (para alimentar la Raspberry Pi)
• Un pequeño LED
• Una resistencia de 250Ω (puede ser cualquier valor cercano a esto)
• Una placa de pruebas sin soldadura
• x2 cables de puente macho a hembra (o macho a macho si tienes un sombrero de encabezado)

Cómo hacer LEDs parpadeantes

Vamos a tomar esto un paso a la vez y hacer que un LED parpadee por sí solo.

1. Abre tu terminal y escribe sudo apt-get install python3-rpi.gpio para instalar el módulo RPi.GPIO para Python 3.

1. Abre un editor de texto y escribe este código:

import RPI.GPIO as GPIO  
from time import sleep  
  
GPIO.setwarnings(False)  
GPIO.setmode(GPIO.BOARD)  
GPIO.setup(7, GPIO.OUT, initial=GPIO.LOW)  
  
while True:  
        GPIO.output(7, GPIO.HIGH)  
print("LED encendido")  
        sleep(1)  
        GPIO.output(7, GPIO.LOW)  
print("LED apagado")  
        sleep(1)

1. Guárdalo en una carpeta en algún lugar. El nombre de la extensión debe ser .py. En mi Raspberry Pi, lo nombré “rpi-blink.py” para facilitar su búsqueda.

1. Apaga tu Raspberry Pi y desconéctala de todas las fuentes de alimentación.
2. Para comenzar a construir el circuito, conecta tu LED de modo que haya una resistencia en el cátodo o en el ánodo, luego apunta el lado del cátodo al pin 7 y el lado del ánodo al pin 9 (GND).

Consejo: para averiguar el número de pin, sostiene tu Raspberry Pi de manera que los pines GPIO estén a la derecha. El pin superior izquierdo es el pin 1, el superior derecho es el pin 2. El que está debajo del pin 1 es el pin 3, luego a la derecha de este es el pin 4, y así sucesivamente.

1. Vuelve a encenderla para que podamos ejecutar el script de Python. Abre tu Terminal y usa cd para moverte a la carpeta del archivo de Python. Escribe:

python3 rpi-blink.py

para hacer que el LED parpadee.

Alternativa: si tienes Thonny Python IDE, entonces haz clic en el botón “Ejecutar script actual” para ejecutarlo directamente desde el IDE.

1. Para detenerlo, presiona Ctrl + C dentro de la terminal. Pero si estás usando Thonny Python IDE, simplemente cierra el editor.

También lee: 10 útiles líneas de código en Python que debes conocer

Cómo funciona el código

Hay dos cosas que hacen que funcione: el código y el circuito. Comenzamos con el código y lo dividimos en tres partes:

1. Comandos de importación
2. Comandos de configuración
3. Comandos en bucle

En la práctica, es bueno pensar en el código como pequeñas funciones agrupadas para hacer funciones más grandes.

Comandos de importación

Python normalmente no hace que sea tan fácil programar pines GPIO. Hay un montón de cosas sucediendo detrás de escena. La buena noticia es que puedes importar el código que maneja todas estas cosas molestas.

Echa un vistazo a las líneas 1 y 2:

import RPI.GPIO as GPIO  
from time import sleep

Estas son un par de líneas que importan código de algo llamado “módulo de Python.”

import RPI.GPIO as GPIO te permite importar el contenido del módulo RPI.GPIO y te permite usar la palabra clave GPIO para llamar a una función relacionada con RPI.GPIO.

Por otro lado, from time import sleep te permite importar la función sleep() del módulo de tiempo incorporado de Python. Esto te permite retrasar la siguiente línea de código por un número dado de segundos.

Comandos de configuración

Algunos códigos tienen que ser “configurados” o definidos de tal manera porque son utilizados por otros códigos para hacer lógica compleja. Llamaremos a estos comandos de configuración.

A diferencia de los comandos de importación, los comandos de configuración no “importan” código de módulos externos. Los importan de los módulos que ya has importado.

Como ejemplo, GPIO.setwarnings(False) importa la función .setwarnings() del módulo RPI.GPIO, que fue definido previamente como GPIO. Esta función detiene una advertencia de activación cuando ejecutas el código. Está configurado en True por defecto.

Para explicar los otros dos, continuamos con GPIO.setmode(GPIO.BOARD). Eso le dice a RPI.GPIO qué tipo de pinout vas a usar. Hay dos tipos: BOARD y BCM. El pinout BOARD te permite elegir pines según sus números. Mientras tanto, el pinout BCM se basa en su designación de canal SOC de Broadcom. Para mantener las cosas cortas, BOARD es más fácil de usar porque siempre es el mismo sin importar qué modelo de Raspberry Pi uses. BCM, por otro lado, tiende a ser diferente de modelo a modelo.

Por último, tenemos GPIO.setup(7, GPIO.OUT, initial=GPIO.LOW) que utiliza la función .setup(), que te pregunta tres cosas: el número de pin, su designación y su valor inicial. El número de pin que estamos usando aquí es el pin número 7. Se supone que debemos configurarlo como un pin de salida y asegurarnos de que comience como LOW. Sin esto, la Raspberry Pi nunca sabrá qué hacer con el pin 7.

Comandos en bucle

Esta es la parte genial. Los comandos en bucle te permiten decirle a la Raspberry Pi que haga cosas. Comenzamos este bucle con while True:, que repite las siguientes líneas de código para siempre.

Hubo tres funciones en el bucle: GPIO.output(), print() y sleep().

• GPIO.output() toma un pin de salida y lo establece en HIGH o LOW. Si pensabas en cambiar qué pin usar en tu Raspberry Pi, entonces deberías haber cambiado 7 por un número de pin de tu elección.
• print() hace que imprima algo en la consola. Toma una cadena, número o variable que contenga las dos anteriores.
• sleep() pausa todo el programa por un cierto número de segundos. Usa un número menor que 1 para hacer que pause por menos de un segundo.

El circuito

Ahora que sabes cómo funciona el código, echemos un vistazo al circuito. El código hace un circuito conectando el pin 7 a GND. Cuando el pin 7 está en HIGH, emite 3.3V que pasa a través de la resistencia y el LED, luego entra en GND. Esto se convierte en un circuito completo y es por eso que el LED se enciende.

Pero, ¿qué sucede cuando el pin 7 está en bajo? Los 3.3V bajan a alrededor de 0V. De esta manera, no pasa electricidad a través del LED, por lo que no se enciende. Puedes pensar en el pin 7 como una especie de interruptor, ya que enciende o apaga el circuito.

¡Hagamos parpadear más LEDs!

Ahora que sabes qué hace que las cosas funcionen, modifiquemos nuestro código un poco para hacer que funcionen dos LEDs.

Para esto, solo necesitarás agregar dos LEDs más de cualquier color y dos resistencias de 250Ω más.

1. Abre tu editor de código nuevamente y pega este código:

import RPI.GPIO as GPIO  
from time import sleep  
  
GPIO.setwarnings(False)  
GPIO.setmode(GPIO.BOARD)  
GPIO.setup(7, GPIO.OUT, initial=GPIO.LOW)  
GPIO.setup(12, GPIO.OUT, initial=GPIO.HIGH)  
GPIO.setup(37, GPIO.OUT, initial=GPIO.LOW)  
  
while True:  
        GPIO.output(7, GPIO.HIGH)  
        GPIO.output(12, GPIO.LOW)  
print("LED encendido @ pin 7")  
print("LED apagado @ pin 12")  
sleep(1)  
        GPIO.output(7, GPIO.LOW)  
        GPIO.output(12, GPIO.HIGH)  
print("LED apagado @ pin 7")  
print("LED encendido @ pin 12")  
sleep(1)  
if x == 1:  
                GPIO.output(37, GPIO.HIGH)  
print("LED encendido @ pin 37")  
                x = 0  
elif x == 0:  
                GPIO.output(37, GPIO.LOW)  
print("LED apagado @ pin 37")  
                x = 1  
else:  
print("Error de lógica")  
sleep(1)

1. Guarda y apaga tu Raspberry Pi.
2. Para cablear el circuito, para cada LED que tengas, conéctalo a una resistencia en serie, luego conecta el lado del cátodo a la Raspberry Pi. Debería haber uno para el pin 7, otro para el pin 12 y el último para el pin 37. El lado del ánodo debe estar conectado a GND. Cada uno de estos pines tiene un pin GND al lado. Esos deberían ser los pines 9, 20 y 39.

Consejo: si te quedas sin cables de puente macho a hembra, puedes conectar un macho a macho a un cable hembra a hembra para formar un cable de puente macho a hembra más largo.

1. Una vez que hayas terminado, enciende la Raspberry Pi y repite el paso 6 para lanzar el script de Python.

También lee: Cómo utilizar Python para tareas básicas de administración de sistemas Linux y redes

Preguntas Frecuentes

¿Por qué mi LED permanece encendido cuando detengo el script?

Cuando la Raspberry Pi lee el script de Python, lee la línea antes de ejecutar el comando. Probablemente lo detuviste justo después de que leyó la línea GPIO.output(7, GPIO.HIGH), por lo que no pudo llevar el pin a LOW primero. Puedes dejarlo así, ya que volverá a LOW la próxima vez que reinicies. Alternativamente, haz otro script de Python que lleve el pin a LOW tan pronto como se ejecute.

Colocé mi LED en el pin correcto, pero no se enciende en absoluto. ¿Por qué?

Hay dos posibles razones: o tu LED está roto o colocaste el cátodo en el lado opuesto. Intenta girar primero los pines del LED.

¿Es seguro colocar el LED al revés?

Sí. Puedes colocarlo al revés, y la corriente simplemente no pasará. Es una característica especial entre los diodos, incluso los diodos emisores de luz; permiten que la electricidad pase por un lado y no por el otro.

¿Es seguro reposicionar el LED mientras la Raspberry Pi está encendida?

Si solo se trata de girar el LED al revés, entonces está bien, y no hay daño allí. Pero si vas a colocar el LED en cualquier lugar, hay una posibilidad de que puedas hacer un cortocircuito entre el pin de 5v y un pin GPIO. Eso va a romper tu placa.