CONTROLANDO LEDS CON UNA RASPBERRY PI

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.
Aclaro que mis conocimientos sobre Python, Linux y Raspberry son limitados, me
considero mas bien un aprendiz. De cualquier manera, siguiendo el acostumbrado
estilo de Inventable, he tratado de ser preciso y exhaustivo.
Entradas y salidas de la Raspberry
Para este proyecto he usado una vieja Raspberry PI Modelo B que tenía abandonada
en un cajón. Ya he hablado de la Raspberry PI en mi artículo "Interfaz experimental
para Raspberry PI", especialmente sobre el conector con entradas y salidas. Las
primeras Raspberry tenían un conector de 26 pines. Modelos más recientes disponen
de uno más grande de 40 pines y por lo tanto con una mayor cantidad de entradas y
salidas.
 Pines del conector
de la Raspberry PI de todos los modelos (versiones de 26 pines y de 40 pines).
Por suerte, en este cambio de conectores se ha mantenido la misma distribución de los
primeros 26 pines iniciales por lo que la descripción de este proyecto es aplicable
para todos los modelos de Raspberry, viejos y nuevos.
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". En el momento que
escribo este artículo la última versión es la 2.4.4. Al interno de NOOBS se encuentra
el sistema operativo Raspbian (Linux Debian para Raspberry PI). El file zip pesa
alrededor de 1,5 Gigabytes.
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. Me 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.

Selección de Raspbian para

instalar desde el software NOOBS.
La instalación continuará sin hacer más preguntas y llevará algunos minutos. Aquí
también han simplificado mucho respecto al pasado.

Imagen en la pantalla
durante la instalación de Raspbian.
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.

Imagen de la
pantalla una vez instalado Raspbian.
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.
 Ventana para la
configuración de Raspbian (nombre usuario, tipo de teclado, idioma, zona horaria,
etc.)
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.
 Indicación para abrir el
terminal
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
 Conexión de los leds
y de los pulsadores directamente al conector de la Raspberry.
Elenco de materiales

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:
 Circuito
con los leds y los pulsadores conectados a la Raspberry PI.
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 Inventable (o
cualquier otro nombre que les guste). Para ello abrimos el File Manager (icono con el
diseño de carpetas).

File Manager abierto en

el directorio PI donde se ve la nueva carpeta "Inventable".
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.
 Indicación para abrir el
editor de textos
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.
 Programas "Terminal"
y "Editor de textos", abiertos contemporáneamente para trabajar mejor.
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:

1 #!usr/bin/env python
2
3 import RPi.GPIO as io
4 import time

Guardamos nuevamente el file "test_leds1.py" con el menú "Save"

Desde el terminal que teníamos abierto escribimos:

cd Inventable <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:

1 #!usr/bin/env python # Necesario para el interprete Python

2
3 import RPi.GPIO as io # Import libreria de I/O (entradas /
4 salidas)
5 import time # Import libreria para los retardos
6
7 led1 = 9 # led 1 conectado al gpio 9 del micro
8
9 button1 = 11 # boton 1 conectado al gpio 11 del micro
10 button2 = 10 # boton 2 conectado al gpio 10 del micro
11
12 io.setmode(io.BCM) # modo in/out pin del micro
13 io.setwarnings(False) # no señala advertencias de pin ya
14 usados
15
16 io.setup(led1,io.OUT) # set pin led 1 como salida
17
18 io.setup(button1,io.IN) # set pin pulsador 1 como entrada
19 io.setup(button2,io.IN) # set pin pulsador 2 como entrada
20
21 for a in range(100): # Ciclo de espera hasta que se acciona
22 time.sleep(0.5) # el pulsador 1
23 if not io.input(button1):
24 break # Con el pulsador 1 accionado (a masa)
25 # termina el ciclo de espera
26
27 while io.input(button2): # Ciclo hasta que se acciona il pulsador
 28 2
29 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.

La Raspberry PI
conectada a la protoboard con los leds y los pulsadores.
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).

Conexiones a la
Rasberry PI
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 estilo de los programas en Python
No obstante Python sea un lenguaje muy intuitivo y fácil de aprender, la
comunidad que lo sostiene mantiene una actitud muy rigurosa respecto al estilo
del código escrito. Creo que esto se debe a dos motivos: el primero está
relacionado a su creador: Guido van Rossum que da mucha importancia a la
estética y a la elegancia del código. El segundo motivo (y no menos importante)
es que el código Python es fundamentalmente "open source" y se condivide en
todo el mundo (especialmente a través de las librerías), por lo tanto es
necesario que el código escrito sea bien legible y claro. Las indicaciones de
estilo más importantes se encuentran en un documento llamado PEP-8 que
aconsejo de leer a los que empiecen (como yo) a trabajar con Python.

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:

1 #!usr/bin/env python # Necesario para el interprete Python

2 """
3 Programa simple que enciende 4 leds conectados
4 a una Raspberry PI en modo secuencial.
5 (CC) BY_NC_SA por Gabriel Rapetti para Inventable
6
7 Uso:
8 -----
9 1. Accionar el pulsador 1 para activar la secuencia
10 2. Accionar el pulsador 2 para terminar el programa
11 """
12
13 import RPi.GPIO as io # Import libreria de I/O (entradas /
14 salidas)
15 import time # Import libreria para los retardos
16
17 led1 = 9 # led 1 conectado al gpio 9 del micro
18 led2 = 8 # led 2 conectado al gpio 8 del micro
19 led3 = 7 # led 3 conectado al gpio 7 del micro
20 led4 = 4 # led 4 conectado al gpio 4 del micro
21
22 button1 = 11 # boton 1 conectado al gpio 11 del micro
23 button2 = 10 # boton 2 conectado al gpio 10 del micro
24
25 io.setmode(io.BCM) # modo in/out pin del micro
26 io.setwarnings(False) # no señala advertencias de pin ya
27 usados
28
29 io.setup(led1,io.OUT) # set pin led 1 como salida
30 io.setup(led2,io.OUT) # set pin led 2 como salida
31 io.setup(led3,io.OUT) # set pin led 3 como salida
32 io.setup(led4,io.OUT) # set pin led 4 como salida
33
34 io.setup(button1,io.IN) # set pin pulsador 1 como entrada
35 io.setup(button2,io.IN) # set pin pulsador 2 como entrada
36
37 for a in range(100): # Ciclo de espera hasta que se acciona
38 time.sleep(0.5) # el pulsador 1
39 if not io.input(button1):
40 break # Con el pulsador 1 accionado (a masa)
41 # termina el ciclo de espera
42
43 while io.input(button2): # Ciclo hasta que se acciona el pulsador
44 2
45 io.output(led4,0) # Apaga el led 4
46 io.output(led1,1) # Enciende el led 1
47 time.sleep(0.1) # Espera medio segundo
48
49 io.output(led1,0) # Apaga el led 1
50 io.output(led2,1) # Enciende el led 2
51 time.sleep(0.1) # Espera otro medio segundo
52
53 io.output(led2,0) # Apaga el led 2
54 io.output(led3,1) # Enciende el led 3
55 time.sleep(0.1) # Espera otro medio segundo
56
57 io.output(led3,0) # Apaga el led 3
58 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.

Conclusiones
Las técnicas de programación en Python pueden ser muy simples o muy sosfisticadas
(por ejemplo con la programación orientada a objetos). En este proyecto he tratado
de reducir la complejidad (ni siquiera funciones he usado) para ser lo más didáctico
posible. Python, Raspberry y Linux son argumentos muy extensos sobre los cuales
pueden encontrar toneladas de artículos en Internet y también tantos libros. En este
artículo quise demostrar que es posible controlar entradas y salidas de una Raspberry
PI en modo sencillo y sin complicaciones, empezando desde cero . Así fue y esto abre
perspectivas muy interesantes en la integración de software de alto nivel y
electrónica.