Caja con botones y pantalla para Raspberry Pi

Existen muchos modelos de cajas para Raspberry Pi y con muchas opciones diferentes cada una de ellas. También hay muchos artículos comparando que carcasa es mejor que otra, disipa más calor, etc. De todas las cajas que he probado hay una que me gusta más que las demás, porque dispone de una pantalla para poder ver que está haciendo el equipo y unos botones que nos permiten hacer algunas funciones básicas. El disponer de un equipo con pantalla y botones facilita el poder llevar la Raspberry Pi sin ayuda de equipos adicionales, si ni quiera para poder apagarla. Además, la carcasa está hecha de aluminio y la pantalla está bastante protegida, por lo que podemos llevarla encima todo el tiempo. En este post indico como configurar la caja para usar la pantalla y los botones.

Estamos hablando de esta caja:

La caja la puedes conseguir bien de SODIAL o bien de DollaTek . Estoy casi seguro que el fabricante es el mismo. La caja no viene con disipadores, por lo que puede que necesites alguno. Con los dos superiores es suficiente, porque para el inferior la caja tiene un pequeño borde que hace contacto con el integrado que se encuentra en esa posición.

Las características de este dispositivo que para mi son más importantes:

• Caja de aluminio, que ayuda a disipar el calor y es resisetente.
• Pantalla para poder ver logs o la salida de comandos directamente en pantalla.
• Seis botones, que permiten por ejemplo apagar la pantalla para ahorrar energía, apagar la Raspberry Pi de forma ordenada, lanzar procesos, etc.
• Sensor de infrarojos, que la mayoría de las cajas no lo tienen
• Zócalo accesible para poder instalar la cámara

Instalación de la caja

La instalación de la caja no presenta ningún tipo de problema y es sencilla.

1. Lo primero es colocar la parte superior (la de la pantalla) boca abajo y colocar los cuatro botones.
2. Quitar los plásticos protectores de la lámina plástico de la pantalla, de la pantalla y de la pieza lateral.
3. Colocar la lámina de plástico de la pantalla en la carcasa.
4. Colocar la pieza lateral y sus botones.
5. Colocar la pantalla en su sitio, poniendo especial atención en que los botones del lateral queden bien colocados.
6. Poner los tornillos hexagonales en su sitio, de forma que la pantalla y todos los botones quedan ya fijos.

Quedará algo similar a la siguiente imagen:

La siguiente fase consiste en colocar los disipadores. Lo primero a tener en cuenta es que los disipadores que pongamos deben ser de perfil bajo, en caso contrario pueden golpear contra la placa de la pantalla. La mayoría de los disipadores ya tienen en cuenta este problema y no miden más de 7 milímetros. Sin embargo, si vas a utilizar una Raspberry Pi 3+, ten en cuenta que este dispositivo tiene un pequeño disipador ya incluido en el procesador principal y eso hace que suba uno o dos milímetros adicionales, por lo que el disipador deberá ser más bajo (unos 5mm). En caso contrario será necesario limar el disipador hasta lograr la altura deseada.

Por otro lado, como puedes observar, en la imagen he marcado una línea roja bastante ancha. Bien, la razón es que al colocar el disipador sobre el integrado que gestiona el puerto Ethernet y los USB, si lo pegamos mucho al conector USB la parte de la carcasa marcada en rojo no entrará y tendremos que mover el disipador.

Colocados los disipadores únicamente queda conectar la Raspberry Pi a la placa de la pantalla y poner la silicona de color azul sobre el chip de la RAM. Esta silicona coincide con el saliente de aluminio que hay en la tapa inferior. Queda de esta forma:

Finalmente necesitarás un destornillador Torx de tamaño T8 para poner los tornillos al cerrar la carcasa.

Configuración del software

Para realizar la configuración de la carcasa vamos a utilizar el sistema operativo Linux, mediante la distribución

Raspbian . Vamos a actualizar el dispositivo a la última versión mediante el comando rpi-update, el cual bajará de Internet el último firmware y otros componentes. Al finalizar reiniciamos el dispositivo con sudo reboot.

Configuración de la pantalla

Lo primero que vamos a configurar es la pantalla. Para ello necesitamos indicarle al kernel que use este dispositivo. Esto se realizad mediante la edición del fichero /boot/config.txt (lo editamos con sudo nano /boot/config.txt), en el que incluiremos estas líneas al final del mismo:

dtparam=i2c_arm=on,spi=on
dtoverlay=pitft28-resistive, rotate=270 speed=48000000 fps=30

También editaremos el fichero de configuración /boot/cmdline.txt (lo editamos con sudo nano /boot/cmdline.txt) e incluiremos en el mismo el texto fbcon=map:10 fbcon=font:VGA8x8 justo antes de la palabra rootwait. El fichero quedará con una línea parecida a la siguiente:

dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline fbcon=map:10 fbcon=font:VGA8x8 rootwait

Ahora solo falta reiniciar el sistema mediante el comando sudo reboot y podremos ver en la pantalla la carga del sistema.

Configuración de los botones

Para la configuración de los botones vamos a usar un procedimiento similar del artículo Shield de infrarojos para Raspberry Pi - botones , si bien lo que cambia es el número de botones y su identificación. En este caso son los siguientes:

El resto del procedimiento es similar:

Comunicación con el núcleo del sistema

El kernel se comunica con este dispositivo utilizando el módulo uinput por lo que lo cargaremos mediante la edición del fichero de configuración /etc/modules, para ello añadiremos al final la siguiente línea:

uinput

Posteriormente será necesario reiniciar el sistemas para que cargue el módulo o bien, podemos cargarlo de forma puntual mediante el comando modprobe uinput. La siguiente vez que arranquemos la Raspberry Pi ya se cargará del fichero /etc/modules.

Instalación del software

Para poder recibir las señales, es necesario utilizar una serie de aplicaciones y librearías. Esta interacción la realizaremos utilizando Python. Para ello, lo primero será necesario instalar el gestor de paquetes de Python, llamado PIP:

sudo apt-get update
sudo apt-get install python-pip libudev-dev

Una vez instalado, procederemos a instalar los paquetes necesarios de Python, que son python-uinput y rpi.gpio. Para ello usaremos el siguiente comando.

sudo pip install python-uinput rpi.gpio

Creación del script de comunicación con los botones

Para comunicarnos con los botones vamos a usar un pequeño script. Este script se va a encargar de escuchar los pines donde se encuentran conectados los botones del shield al GPIO de nuestra Raspberry Pi. Los pines usados son los indicados anteriormente.

El siguiente paso es construir el script para procesar las pulsaciones. Para ello, creamos un fichero, en mi caso he editado el fichero ~/src/rpibtn.py y he incluido la siguiente información:

#!/usr/bin/env python
import RPi.GPIO as GPIO
import time
import subprocess
import sys
import os

# Get the scripts folder
def get_scripts_folder():
    return os.path.dirname(sys.argv[0]) + "/scripts/"

def select_o_Button(bouncetime):
    print "Button Circulo"

def select_s_Button(bouncetime):
    print "Button Cuadrado"

def select_t_Button(bouncetime):
    print "Button Triángulo"

def select_x_Button(bouncetime):
    print "Button Aspa"

def select_u_Button(bouncetime):
    print "Button Lateral 1"

def select_d_Button(bouncetime):
    print "Button Lateral 2"

def gpio_setup():
    GPIO.setwarnings(False)
    GPIO.setmode (GPIO.BCM)

    GPIO.setup(23, GPIO.IN, pull_up_down = GPIO.PUD_UP) # o - Circle Button
    GPIO.setup(22, GPIO.IN, pull_up_down = GPIO.PUD_UP) # s - Square button
    GPIO.setup(24, GPIO.IN, pull_up_down = GPIO.PUD_UP) # t - Triangle Button
    GPIO.setup( 5, GPIO.IN, pull_up_down = GPIO.PUD_UP) # x - X Button
    GPIO.setup( 4, GPIO.IN, pull_up_down = GPIO.PUD_UP) # u - Up button
    GPIO.setup(17, GPIO.IN, pull_up_down = GPIO.PUD_UP) # d - Down button

    GPIO.add_event_detect(23, GPIO.FALLING, callback=select_o_Button, bouncetime=500)
    GPIO.add_event_detect(22, GPIO.FALLING, callback=select_s_Button, bouncetime=500)
    GPIO.add_event_detect(24, GPIO.FALLING, callback=select_t_Button, bouncetime=500)
    GPIO.add_event_detect( 5, GPIO.FALLING, callback=select_x_Button, bouncetime=500)
    GPIO.add_event_detect( 4, GPIO.FALLING, callback=select_u_Button, bouncetime=500)
    GPIO.add_event_detect(17, GPIO.FALLING, callback=select_d_Button, bouncetime=500)

gpio_setup()

while True:
    time.sleep(2)

El script llama a la función gpio_setup(), que se encarga de esperar eventos desde los pines de cada uno de los botones. Cuando llega un evento, se ejecuta la función select_<letra>_Button donde letra es la inicial en inglés del nombre del botón en inglés (excepto el circulo, que he puesto una o).

Las funciones imprimen el nombre botón pulsado.

Para ejecutar el fichero, primero lo haremos ejecutable mediante el comando chmod:

chmod +x ~/rpibtn.py

Y finalmente lo ejecutaremos:

~/rpibtn.py

Apagar y encender la pantalla

En este dispositivo es importante conocer como apagar y encender la pantalla, dado que nos permite entre otras cosas ahorrar batería. Se realiza enviando al pin 27 mediante GPIO la señal HIGH para encenderlo y la señal LOW para apagarlo. Los scripts son los siguientes:

Encender el backlight:

#!/usr/bin/env python
import RPi.GPIO as GPIO

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(27, GPIO.OUT)
GPIO.output(27,GPIO.HIGH)

Apagar el backlight:

#!/usr/bin/env python
import RPi.GPIO as GPIO

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(27, GPIO.OUT)
GPIO.output(27,GPIO.LOW)

Enlaces de interes:

Os dejo en mi página de Github los scripts que utilizo para este dispositivo y para otros que también usan GPIO de Raspberry Pi.