Como dije en el anterior post, hace poco que encargué una Raspberry Pi con la intención de convertirla en un repeater de la red del vecino, NAS, servidor de impresión, descarga de torrents, etc.. (lo que se me vaya ocurriendo)
Como la idea es que siempre este encendida y funcionando en background, no necesito un monitor conectado por HDMI las 24h, por lo que simplemente necesitaré conectarme en caso de error o cuando quiera configurar algo.
Por supuesto, me puedo conectar mediante ssh o incluso mediante UART (puerto serie) conectando un adaptador USB TTL a los pines RX y TX del conector de GPIOs, pero también es cierto que donde este una buena pantalla que se quite todo lo demás.
Echando un vistazo al repertorio de displays OLED y TFT que tengo para utilizarlos con Arduinos, ESP8266s y demás micros, se me ocurrió que quizás podría adaptarle una TFT que tenia de 2,4 pulgadas de los chinos, que funciona mediante el protocolo SPI.
En concreto se trata de un display TFT con driver ILI9341 que te sale por unos 6 dolares en Ebay, con una modestísima resolución de 320×240 píxeles (en apaisado) a color, pero más que suficiente para que te saque de un apuro o incluso, para mostrar información de modo permanente.
Como la Raspberry Pi tiene pines GPIO (General Purpose Input Output) como cualquier otro micro electrónico, soporta SPI por hardware y funciona con señales lógicas de 3.3V como el propio display (no hay necesidad de hacer level shifting), me puse a investigar si existía alguna manera de enviar la shell de Linux directamente a la pantalla y ya puestos, si se podía hacer lo mismo con las X (el entorno gráfico).
Y sí, la respuesta es SI SE PUEDE aunque es un poquito más complicado que simplemente conectar un monitor por VGA, HDMI, etc. En concreto, se puede conseguir gracias a un proyecto que creó drivers para diferentes displays y que actualmente, ya forma parte del código del kernel de Linux. Podéis encontrar mas info aquí: https://github.com/notro/fbtft y todos los displays soportados aquí: https://github.com/notro/fbtft/wiki/LCD-Modules. Como véis, abarca desde los típicos displays tipo Nokia antiguos, pasando por los mini OLEDs, TFTs, etc…
Paso 1. Conexion del display TFT a la Raspberry Pi.
Como he dicho, el display funciona a 3,3V y por SPI (Serial Peripherical Interface), nada de vídeos compuestos, HDMIs, VGAs u otro tipo de señales. Si no lo sabías, la gran mayoría de periféricos para electrónica como displays tipo OLED o TFT, sensores, etc.. funcionan o por SPI o por I2C, que son 2 de los protocolos serie mas comunes en electrónica (y otros UART, etc.. también, pero para otras cosas).
Lo importante del asunto, es saber que pines conectar entre el display y la Raspberry Pi para que todo funcione.
Por una parte, vamos a partir del siguiente esquema de pines de la Raspberry Pi 2, pero es igualmente válido para Raspberry 1 model B, ya que también tiene 40 pines.
Y por otro lado, detrás del display, tenemos serigrafiada la función de cada pin. Cabe destacar que toda la parte destinada al touch screen (pines bajo el nombre TOUCH) no se utilizan para nada y el pin MISO, tampoco, ya que la pantalla solo recibe datos, no tiene que enviar nada. Además, los conectores superiores destinados al lector de tarjetas SD incorporado, tampoco será utilizado.
Los pines que debemos conectar desde el display a la Raspberry Pi son los siguientes:
| Raspberry Pi | Display TFT 2.4 ILI9341 | Mas Info |
|---|---|---|
| PIN 1 – 3.3V PWR | VCC | Los 3,3 voltios requeridos para que funcione la pantalla |
| PIN 9 – GND | GND | Toma tierra |
| PIN 24 – SPI0 CS0 | CS | El Chip Select de SPI para que la pantalla sepa cuando los datos que se envien por SPI son para ella |
| PIN 22 – GPIO 25 | RESET | Reseteo del chip |
| PIN 18 – GPIO 24 | D/C | Data/Command. Aunque no es parte de SPI, sirve para decirle a la pantalla cuando se envian comandos y cuando datos. |
| PIN 19 – SPI0 MOSI | (MOSI) | Master output slave input. Los datos y comandos que el display ejecutara se envian por aqui |
| PIN 23 – SPI0 SCLK | SCK | La senal de reloj que nos permite sincronizar las comunicaciones por SPI |
| PIN 12 – GPIO 18 | LED | La backlight o la luz LED que esta detras del panel LCD y que ilumina a este |
Una vez que hayáis conectado todo, debe quedar algo parecido como lo siguiente:
A destacar que el pin VCC lo podrías cambiar a otro pin 3.3V, así como el GND a cualquier GND libre. Además, los pines RESET, D/C y LED a cualquier GPIO disponible. Todo dependerá si ya tenías algo conectado a estos pines o no. Solo recuerda que GPIOs has utilizado para RESET, D/C y LED, ya que posteriormente se lo debemos comunicar al driver pertinente.
Paso 2. Configuracion del kernel de Linux y carga de drivers
Una vez que tenemos todo conectado como se indica en el apartado anterior, el siguiente paso sera configurar el kernel de Linux para que cargue los drivers necesarios para el manejo del display.
Yo en mi caso particular, estoy utilizado Raspbian, que es el Sistema Operativo por defecto que se suele utilizar con Raspberry Pi, pero en realidad lo podríais utilizar con cualquier otro sabor de Linux, siempre y cuando el kernel que utilicéis tenga los drivers apropiados. En caso que no los tenga, os tocará compilarlos, pero esto está fuera del alcance de este post.
Como dije anteriormente, los drivers que vamos a utilizar son los Frame Buffer TFT que podéis encontrar aquí: https://github.com/notro/fbtft, y que ya están integrados en las ultimas versiones del kernel de Linux.
Antes de utilizar estos drivers, asegúrate que has actualizado tu Raspbian a la última versión con un raspi-update, apt-get update y toda la mandanga. Si no sabes como se hace, busca por Internet.
Para utilizar los drivers de la pantalla, debemos cargar otros necesarios como el driver que controla SPI y desactivar ciertas funcionalidades como el device tree para evitar problemas, ya que no vamos utilizar overlays.
Tanto para desactivar device tree como para cargar el driver SPI, lo podemos hacer de 2 formas:
A través de raspi-config:
sudo raspi-config
– Para desactivar device tree: Seleccionamos “8 Advanced Options”, después “A5 Device tree” y cuando nos pregunte “Would you like the kernel to use Device Tree” seleccionamos “No”
– Para cargar el driver SPI: Seleccionamos “8 Advanced Options”, después “A6 SPI” y cuando nos pregunte “Would you like the SPI kernel module to be loaded by default” seleccionamos “Yes”
A pelo, editando el fichero /boot/config.txt que se lee cada vez que el kernel se carga:
Añadimos los siguiente:
device_tree= dtparam=spi=on
Guardamos todo y reiniciamos el sistema con un:
sudo reboot
Con esto, ya tenemos el device tree desactivado y el driver SPI cargado. Pasemos ahora a cargar el driver del display.
Para que se cargue cada vez que arranca el sistema, debemos editar el fichero /etc/modules y añadir lo siguiente:
fbtft dma fbtft_device custom name=fb_ili9341 gpios=reset:25,dc:24,led:18 speed=48000000 fps=50 rotate=90 bgr=1
La primera linea activa el soporte DMA y la segunda, es el driver especifico para el display que tiene varias opciones entre ellas.. gpio=reset:25… que es ahí donde se le especifican los GPIO de Raspberry Pi que hemos utilizado para conectar los pines RESET, D/C y LED. el parámetro speed es la velocidad de refresco, fps los frames por segundo, etc..
Tenéis mas información sobre estos parámetros en: https://github.com/notro/fbtft/wiki/fbtft_device
Si en este punto reiniciamos la Raspberry Pi, veremos que como mucho se ilumina la pantalla pero no muestra nada, ya que se ha cargado el driver cuando se ha iniciado el sistema pero no hemos enviado nada de nada a esta pantalla.
Paso 3. Envío de la shell y de las X por defecto hacia el display
El display que le hemos conectado lo podríamos utilizar para enviar vídeo, imágenes o lo que queramos bajo petición, pero en mi caso, he querido utilizarlo a modo de monitor, es decir, que me muestre todo lo que se mostraría en un monitor normal en este display, tanto la shell como el modo gráfico.
Para hacer esto, vamos utilizar un programa que automaticamente copiará el frame buffer 0 hacia frame buffer 1(/dev/fb0 hacia /dev/fb1), o lo que es lo mismo, del frame buffer primario al frame buffer del display. El programa en cuestión es https://github.com/tasanakorn/rpi-fbcp, el cual vamos a tener que clonar de Github y compilar en nuestra Raspberry Pi de la siguiente manera:
sudo apt-get install cmake git clone https://github.com/tasanakorn/rpi-fbcp cd rpi-fbcp/ mkdir build cd build/ cmake .. make sudo install fbcp /usr/local/bin/fbcp
No deberíais tener mayores problemas, pero si encontráis que os falta alguna dependencia, pues la instaláis para poder compilar e instalar fbcp.
Finalmente, una vez compilado e instalado fbcp bajo /usr/local/bin/fbcp, solo debemos hacer que el sistema llame a este programa cada vez que se inicie. Lo logramos editando el fichero /etc/rc.local y añaadiendo al final:
/usr/local/bin/fbcp &
Por último, reiniciamos y pasados unos cuantos segundos, si has seguido las instrucciones al pie de la letra, justo antes de preguntarnos por el login, ya podremos ver la shell en nuestro display made in china. Asimismo, al cargar las X con un “startx”, podremos ver el entorno gráfico también a través del display.
No es una resolución como para tirar cohetes, pero mas que suficiente si tenemos que configurar alguna cosa puntual o queremos mostrar una información en concreto sin tener que conectar nuestra Raspberry Pi a un monitor externo.
Ah!!! y sí, estoy utilizando un tupper!! nada más barato y efectivo para tus proyectos de electrónica 😀
