Electrónica y Programación en Personal
«Si no se soluciona con un script en Python entonces no es viable»

por Yeison Cardona el 20 de octubre del 2013 a las 4:24 am UTC

Actualización 19/Nov/2013:

Actualizo la imágenes ya que estaba confundiendo las revisiones de Raspberry, y aclaro la diferencia entre ambas con estas ilustraciones.

Distribución de Pines para la revisión 1.
Distribución de Pines para la revisión 2.



Una de las muchas cosas buenas que trae Raspberry es que viene con pines digitales de entrada salida, los GPIO, que los podemos usar como si se tratara de los pines de Pinguino, esta bien, no tanto, la velocidad de reacción es muy (muy, muy) lenta, además de que «incierta», nada nos puede asegurar que la orden de manipulación de pines se cumplan finalmente, es decir, Raspberry NO ES UN SISTEMA EN TIEMPO REAL, así que este tipo de plataformas no podrán reemplazar ni a Pinguino ni a Arduino.

Pero podemos aunque sea encender y apagar unos cuantos LEDs (que emoción ¬¬).

A que me ha quedado mona mi Raspberry :)

Identificación de los pines

De seguro que ya sabrás a cuales pines me refiero, pero por si acaso...
Son los conectores tipo jumpers que se encuentran soldados en la tarjeta, justo al lado de la conexión RCA video, son dos hileras de 13 pines para un total de 26, 2 salidas de 5V, 5 Tierras, 2 salidas de 3.3V y 17 entradas/salidas digitales, en realidad son mas que simples entradas/salidas pero para el propósito de esta guía será suficiente.

Distribución de Pines para la revisión 2.

Instalar GPIO Admin

Uno de los problemas con los GPIO es que debemos ser siempre root para poderlos usar, entonces vamos a poner un poco de orden en este asunto, para ello usamos Quik2Wire GPIO-Admin. Entonces ejecutamos:

sudo su
pacman -S --noconfirm git make gcc
git clone https://github.com/quick2wire/quick2wire-gpio-admin.git
cd quick2wire-gpio-admin
make
make install
cd

Para ejecutar el comando anterior es importante ser root (nos se vale usar sudo con nuestro usuario normal)

Agregar usuario

Si ya tenemos un usuario podemos pasar a Modificar usuario.
Muy importante, no podemos andar por ahí en GNU/Linux siendo ROOT todo el tiempo, las «normas de buenos linuxseros» no lo permiten.
Entonces, para crear mi usuario yeison:

useradd -m -g users -G audio,lp,optical,storage,video,wheel,games,power,scanner,gpio -s /bin/bash yeison
passwd yeison

Un usuario bastante completo (sólo para estar seguros), podrán notar que el nuevo usuario pertenece al grupo gpio, bueno, pues esto es de lo que hablábamos antes, para poder administrar los GPIO.

Para poder usar nuestro nuevo usuario libremente sería conveniente poderlo usar con sudo, entonces también lo instalamos

pacman -S --noconfirm sudo 

Ahora abrimos el archivo /etc/sudoers

nano /etc/sudoers

y buscamos las siguientes líneas:

## Uncomment to allow members of group wheel to execute any command
# %wheel ALL=(ALL) AL

las editamos para que queden:

## Uncomment to allow members of group wheel to execute any command
%wheel ALL=(ALL) AL

guardamos cambios y salimos, ahora, nuestro usuario puede usar sudo, comprobemos:

[root@alarmpi ~]# su - yeison
[yeison@alarmpi ~]$ sudo pacman -S

We trust you have received the usual lecture from the local System
Administrator. It usually boils down to these three things:

    #1) Respect the privacy of others.
    #2) Think before you type.
    #3) With great power comes great responsibility.

Como última prueba vamos a salir de SSH, e iniciar de nuevo, pero esta vez con nuestro nuevo usuario, de ahora en adelante seguir de esta manera.

[yeison@alarmpi ~]$ exit
logout
[root@alarmpi ~]# exit
logout
Connection to 10.42.0.56 closed.
ssh yeison@10.42.0.56
yeison@10.42.0.56's password: 
[yeison@alarmpi ~]$ 

Modificar usuario existente

En el caso de que ya tengamos un usuario entonces sólo debemos agregarlo al grupo gpio, así:

sudo su
gpasswd -a usuario gpio

Ahora si, el blinkLED

Y todo lo anterior fue para seguir la buenas prácticas de GNU/Linux, ahora ya podemos encender y apagar un LED ¬¬

Hay dos maneras de hacerlo, desde una terminal con comandos (realmente poco prácticos) o desde un cómodo módulo para Python, y como pueden adivinar, usaré Python :)

Instalando dependencias

Voy a suponer que siguen mi guía desde el inicio y están usando Arch Linux ARM, entonces vamos a usar Python3, instalarlo si no lo está.

#sudo pacman -S --noconfirm python ipython

de paso instalaré iPython.

Ahora instalar el módulo que hace la «magia»,
Yo prefiero el módulo de Quick2Wire en lugar del clásico RPi-GPIO, sólo por capricho, nada mas.

git clone https://github.com/quick2wire/quick2wire-python-api
cd quick2wire-python-api
sudo python setup.py install

Consultar revisión

Hay dos revisiones, según ésta, algunos pines cambian de nombre, primero vamos a confirmar la nuestra, lo podemos hacer desde el mismo módulo Python que acabamos de instalar, así que lanzamos iPython

ipython
Python 3.3.2 (default, Sep  6 2013, 07:18:43) 
Type "copyright", "credits" or "license" for more information.

IPython 1.1.0 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: 

Entonces procedemos a usar la línea de comandos:

In [1]: import quick2wire.gpio as gpio

In [2]: gpio.revision()
Out[2]: 2

In [3]: 

En mi caso se trata de la revisión 2, muy probable que la de ustedes también.

Identificación de los pines

Al parecer cada software para la manipulación de pines tiene sus propias ideas para administrar los pines, unos usan la numeración el conector, otros se basan en la documentación de Raspberry y unos tantos siguen el SOC ¿? ¬¬

En realidad es muy sencillo, en nuestro caso vamos a usar el pin 11 (según el orden del conector), este mismo pin corresponde al GPIO 17 según Raspberry y al GPIO 0 según el SOC.

Correspondencia de pines Raspberry (rev2) <-> SOC)

Con la imagen anterior queda todo un poco mas claro (espero), nos interesa la numeración según el el SOC, así es como funciona el módulo Python que estamos usando.

blinkLED

Ahora si, de verdad vamos a encender y apagar un LED, lo conectamos como deseemos (de seguro si lees este blog sabrás cómo, como mínimo), yo voy a usar el GPIO0 (SOC), entonces:

In [3]: from quick2wire.gpio import pins, Out

In [4]: led  = pins.pin(0, direction=Out) #Configuramos el pin como salida y creamos el objeto led para este pin

In [5]: led.open() #Abrimos el puerto

In [6]: led.set(1) #Lo ponemos en estado alto

In [7]: led.set(0) #Y luego en bajo

O un blink constante:

In [8]: from time import sleep as delay

In [9]: for i in range(10):
   .....:     led.set(0)
   .....:     delay(0.5)
   .....:     led.set(1)
   .....:     delay(0.5)
   .....:     

Y el led parpadeará 10 veces cada medio segundo.

BlinkLED desde la terminal (No Python)

También podemos usar los GPIO desde la terminal, con comandos «simples», todo esto con ayuda del GPIO Admin que permite hacerlo sin necesidad de ser root, veamos como:

Me he cambiado al GPIO 04 (según Raspberry, no aplica SOC en este caso)

Preparamos el pin con ayuda del comando gpio-admin

[yeison@alarmpi ~]$ gpio-admin export 4
[yeison@alarmpi ~]$ echo "out" > /sys/class/gpio/gpio4/direction

Si, así es como le «decimos» que sea una salida, ¿recuerdan que TODO en Linux es un archivo?, bueno adivinen qué...

Y los estados los cambiamos de la siguiente manera:

[yeison@alarmpi ~]$ echo "1" > /sys/class/gpio/gpio4/value 
[yeison@alarmpi ~]$ echo "0" > /sys/class/gpio/gpio4/value 

Básicamente estamos escribiendo sobre un archivo para cambiar el estado, entonces para leer un puerto, adivinaron, sería algo como:

[yeison@alarmpi ~]$ gpio-admin export 18
[yeison@alarmpi ~]$ echo "in" > /sys/class/gpio/gpio4/direction
[yeison@alarmpi ~]$ cat /sys/class/gpio/gpio18/value 
0
[yeison@alarmpi ~]$

No olviden nunca exportar el pin al inicio, como buena práctica desexportarlo (siquiera existe esta palabra).

[yeison@alarmpi ~]$ gpio-admin unexport 4
[yeison@alarmpi ~]$ gpio-admin unexport 18

Conclusiones

Realmente no creo que Raspberry esté hecha para esto, su potencial está en otras áreas, vemos como hay ejemplos usando un display LCD, pero, ¿de verdad?, que inútil es eso, es como usar un camión para remolcar una bicicleta, ¿entienden a lo que me refiero?. Como lo dije antes, ni consideren usar Raspberry para un proyecto sobre tiempo real duro, usen Pinguino Project para esas cosas.


También podría interesarte:

Añadir un comentario:
Si desean una respuesta para su comentario sólo deben agregarme en G+ y hacer una mención a Yeison Cardona, así les podré responder lo antes posible.