Hola gente, hoy publico un proyecto que consiste en controlar las entradas y las salidas de una Raspberry PI con un simple programa hecho en lenguaje Python.
Entradas y salidas de la Raspberry
Instalación del sistema operativo
Como SD (o microSD en los modelos más modernos) podemos usar una de 8 Giga con buena velocidad (Clase 10). Desde el sito oficial de Raspberry PI bajamos el software NOOBS en formato zip, sigla de «New Out of the box software».
El software NOOBS es estupendo, basta descomprimirlo y copiar su contenido en la SD que usaremos. Metemos la SD en la Raspeberry y conectamos la alimentación de 5V a la plaqueta. Recuerdo que años atrás el procedimiento era mucho más complicado. Una vez encendida la tarjeta, el software pregunta si queremos instalar Raspbian o LibreELEC_RPi, elegimos Raspbian.
La instalación continuará sin hacer más preguntas y llevará algunos minutos. Aquí también han simplificado mucho respecto al pasado.
Una vez instalado todo, aparece el desktop de Linux Raspbian y desde la barra del menú ubicada en alto de la pantalla seleccionamos «Preference» y después Raspberry Pi Configuration.
Aquí podemos elegir el idioma, el tipo de teclado que estamos usando, la zona horaria donde nos encontramos y si lo deseamos podemos cambiar el nombre de usuario y la password aunque si esto último no es necesario. He preferido de mantener la versión en inglés del sistema operativo en el caso que este artículo sea traducido en otros idiomas.
Para la conexión WiFi tuve que agregar un módulo externo porque la mía Raspberry no lo tenía incorporado como en las últimas versiones. Una vez conectado en el puerto USB, en la derecha de la barra del menú del desktop (zona de notificaciones), hay un icono que permite de elegir la red a la cual conectarse.
Actualización del sistema operativo
Todos los programas necesarios para este proyecto se encuentran ya instalados en la distribución de Raspbian incluida en el file NOOBS que hemos bajado.
De cualquier manera, antes de continuar, es conveniente actualizar el sistema operativo. Para ello, abrimos el terminal y escribimos:
sudo apt-get update <RETURN>
Este comando actualiza la lista de los software con las versiones más recientes pero no instala nada. Una vez que ha terminado, para efectuar la verdadera actualización de los paquetes, escribimos el comando:
sudo apt-get upgrade <RETURN>
A un cierto punto apt-get nos preguntará si confirmamos la actualización. Tocamos la tecla «Y» y después hará todo el trabajo (puede llevar algunos minutos). Una vez que ha terminado podemos cerrar el terminal y estamos listos para iniciar el proyecto.
La conexión de leds y pulsadores
4 leds (no importa el color)
2 resistencias de 4,7K
4 resistencias de 470 ohms
2 pulsadores (indicados en el circuito como «push»).
Podemos conectar todo al vuelo, directamente sobre el conector de las Raspberry, usar una base experimental (breadboard) como yo he hecho o cualquier otro método. El circuito es muy sencillo e pueden verlo en la figura siguiente:
Podemos observar que los pulsadores trabajan en modo invertido porque se encuentran conectados a masa. En condiciones de reposo, las dos líneas de entrada de los pulsadores están a positivo de 3,3V (nivel lógico 1) a través de las dos resistencias de 4,7K. Cuando presionamos los pulsadores, estás líneas irán a masa (nivel lógico 0).
Preparando todo para escribir el programa
Antes de empezar, nos conviene crear una nueva carpeta llamada (cualquier nombre que les guste). Para ello abrimos el File Manager (icono con el diseño de carpetas).
Al abrirlo nos mostrará el contenido de la carpeta principal PI. Hacemos click con la tecla derecha del mouse en una parte vacía de la ventana de la derecha. Nos aparece un menú contextual, elegimos New -> Folder y escribimos el nombre de la nueva carpeta.
Ahora abrimos dos programas: el terminal y el editor de textos (Menu Accessories -> Text Editor). Distribuimos las dos ventanas para poder verlas contemporáneamente en la pantalla.
En el editor de textos abrimos el menú «Options» y hacemos click sobre «Line Number» y también sobre «Auto Indent». Después guardamos el nuevo file (que por ahora está vacío) con el nombre «test_leds1.py» en la carpeta Inventable que habíamos creado.
Ahora en el editor, escribimos el siguiente texto:
#!usr/bin/env python
import RPi.GPIO as io
import timeGuardamos nuevamente el file «test_leds1.py» con el menú «Save»
Desde el terminal que teníamos abierto escribimos:
cd nombre carpeta <RETURN>
Después escribimos:
python3 test_leds1.py <RETURN>
Si no aparece ningún mensaje de error significa que Python está funcionando y que encontró las dos librerías necesarias.
El primer programa
Volvemos a nuestro editor y escribimos la primera versión de nuestro programa que enciende un solo led en modo intermitente cuando activamos el primer pulsador mientras que el segundo pulsador nos sirve para terminar el programa.
Este es el código completo:
#!usr/bin/env python # Necesario para el interprete Python
import RPi.GPIO as io # Import libreria de I/O (entradas / salidas)
import time # Import libreria para los retardos
led1 = 9 # led 1 conectado al gpio 9 del micro
button1 = 11 # boton 1 conectado al gpio 11 del micro
button2 = 10 # boton 2 conectado al gpio 10 del micro
io.setmode(io.BCM) # modo in/out pin del micro
io.setwarnings(False) # no señala advertencias de pin ya usados
io.setup(led1,io.OUT) # set pin led 1 como salida
io.setup(button1,io.IN) # set pin pulsador 1 como entrada
io.setup(button2,io.IN) # set pin pulsador 2 como entrada
for a in range(100): # Ciclo de espera hasta que se acciona
time.sleep(0.5) # el pulsador 1
if not io.input(button1):
break # Con el pulsador 1 accionado (a masa)
# termina el ciclo de espera
while io.input(button2): # Ciclo hasta que se acciona il pulsador 2
io.output(led1,1) # Enciende el led
time.sleep(0.5) # Espera medio segundo
io.output(led1,0) # Apaga el led
time.sleep(0.5) # Espera otro medio segundo
Para probarlo, escribimos nuevamente en el terminal (que hemos dejado abierto):
python3 test_leds1.py <RETURN>
El led inicialmente tendría que esta apagado, cuando accionamos el pulsador 1, empezará a destellar en modo intermitente hasta que accionamos el pulsador 2 que termina el programa. El terminal se recuerda los textos que hemos escrito. Para seleccionarlos basta moverse con las flechas del teclado.
Ahora explico como funciona el programa. El extraño texto en el primer renglón (#!usr/bin/env python) sirve para decirle a Python que efectivamente este es un programa Python. En el renglón 3 importamos la parte GPIO de la librería RPi y que maneja los puertos de entrada y salida de las Raspberry. Observen que usando «as io» decimos a Python que desde este momento para referirnos a esta parte del la librería escribiremos solo «io» en vez de RPi.GPIO porque es más sintético.
En el renglón 4 importamos la librería «time» que nos permite de crear retardos y temporizaciones.
En los renglones 6, 8 y 9 le decimos a Python que el led 1 se encuentra conectado a la GPIO 9 del microcontrolador mientras que los pulsadores están conectados a los GPIO 10 y 11. Para este primer programa usaremos solo un led para no complicar demasiado las cosas.
En el renglón 11, con el comando io.setmode (io.BCM), decimos a Python que los números que estamos usando corresponden a las entradas y a las salidas del micro. Si hubiésemos usado io.setmode (io.BOARD) los números corresponderían a los números de los pines del conector de las Raspberry. Yo por tradición prefiero referirme al micro.
En el renglón 12, con io.setwarnings(False) le decimos a Python de no mostrarnos advertencias de pines ya ocupados para otras funciones.
En el renglón 14 decimos a Python que el pin conectado al led 1 es una salida mientras que en los renglones 16 y 17 le decimos que los pines conectados a los pulsadores son entradas.
En el renglón 19 creamos un bucle (loop) que espera hasta que activamos el pulsador 1. He usado un «for» de 100 ciclos en lugar de «while» porque en el caso de problemas con la activación del pulsador 1 (por ejemplo en el caso de error en la conexiones), después de 50 segundos (100 ciclos de medio segundo), termina «si o si» el bucle evitando que el programa quede bloqueado en un loop infinito sin saber si el programa está funcionando.
En el renglón 25 empieza el bucle de intermitencia del led, a través de la instrucción while y seguirá adelante hasta que activemos el pulsador 2. Observen que el código del programa en algunas partes se encuentra separado del margen izquierdo por espacios. Esto se llama identación (derivado del inglés identation) o más correctamente es castellano: sangrado y es muy importante en Python porque sirve para distinguir los bloques de código (como en el caso de las instrucciones end if o next del basic o los símbolos { } del C o derivados).
Los expertos de Python aconsejan de usar una identación (o sangrado) de 4 espacios y sin usar tabulaciones. Quizás en futuro hablaré más de este tema pero por ahora les digo de respetar correctamente este sangrado porque si no lo hacen el programa no funcionará correctamente.
El segundo programa
Una vez que el programa funciona correctamente podemos escribir una versión más sofisticada del mismo que usa los 4 leds. Desde el editor creamos un nuevo file que lo llamaremos test_leds2.py y lo guardamos. Después escribimos lo siguiente:
#!usr/bin/env python # Necesario para el interprete Python
"""
Programa simple que enciende 4 leds conectados
a una Raspberry PI en modo secuencial.
(CC) BY_NC_SA por Gabriel Rapetti para Inventable
Uso:
-----
1. Accionar el pulsador 1 para activar la secuencia
2. Accionar el pulsador 2 para terminar el programa
"""
import RPi.GPIO as io # Import libreria de I/O (entradas / salidas)
import time # Import libreria para los retardos
led1 = 9 # led 1 conectado al gpio 9 del micro
led2 = 8 # led 2 conectado al gpio 8 del micro
led3 = 7 # led 3 conectado al gpio 7 del micro
led4 = 4 # led 4 conectado al gpio 4 del micro
button1 = 11 # boton 1 conectado al gpio 11 del micro
button2 = 10 # boton 2 conectado al gpio 10 del micro
io.setmode(io.BCM) # modo in/out pin del micro
io.setwarnings(False) # no señala advertencias de pin ya usados
io.setup(led1,io.OUT) # set pin led 1 como salida
io.setup(led2,io.OUT) # set pin led 2 como salida
io.setup(led3,io.OUT) # set pin led 3 como salida
io.setup(led4,io.OUT) # set pin led 4 como salida
io.setup(button1,io.IN) # set pin pulsador 1 como entrada
io.setup(button2,io.IN) # set pin pulsador 2 como entrada
for a in range(100): # Ciclo de espera hasta que se acciona
time.sleep(0.5) # el pulsador 1
if not io.input(button1):
break # Con el pulsador 1 accionado (a masa)
# termina el ciclo de espera
while io.input(button2): # Ciclo hasta que se acciona el pulsador 2
io.output(led4,0) # Apaga el led 4
io.output(led1,1) # Enciende el led 1
time.sleep(0.1) # Espera medio segundo
io.output(led1,0) # Apaga el led 1
io.output(led2,1) # Enciende el led 2
time.sleep(0.1) # Espera otro medio segundo
io.output(led2,0) # Apaga el led 2
io.output(led3,1) # Enciende el led 3
time.sleep(0.1) # Espera otro medio segundo
io.output(led3,0) # Apaga el led 3
io.output(led4,1) # Enciende el led 4
time.sleep(0.1) # Espera otro medio segundo
io.output(led4,0) # Apaga el led 4 antes de terminar el programa
El programa es muy similar al primero, con la diferencia que hemos declarado 4 leds en lugar de uno y que el ciclo «while» enciende y apaga los leds en secuencia. El funcionamiento de los pulsadores es similar.
-
Infrarojo seguidor de linea¡Oferta!$3.50$1.75 -
Kit Raspberry – Sensor de lluvia FR-04¡Oferta!$97.00$92.50 -
Case para Raspberry Pi 3¡Oferta!$10.00$6.99
