Raspberry Pi como centro de entretenimiento al volante

El proyecto, desarrollado por Michal Szwaj, plantea un sistema para un vehículo en el que es posible controlar la reproducción multimedia o acceder a los mapas de Google, aunque de momento no ofrece funciones como la navegación GPS, pero la versatilidad de la Raspberry Pi con el soporte Bluetooth ,hace que esa opción no parezca difícil de implementar.

OpenAuto, es un proyecto que con una Raspberry Pi 3 y una pantalla táctil nos da acceso a unas funciones muy similares a las que ofrece Android Auto, basándose en la biblioteca aasdk y librerías Qt siendo el objetivo principal ejecutar esta aplicación en una placa de RaspberryPI 3 sin problemas. El proyecto se basa en la instalación de una distribución Linux, Raspbian Stretch, a la que luego se le añaden librerías como las célebres Qt para poder ejecutar las aplicaciones orientadas a ser utilizadas en el coche.

A la Raspberry Pi 3 se le conecta una pantalla táctil (480p, 720p o 1080p) pues este es recomendable para la interacción con el sistema. Completar el proceso es relativamente sencillo, y tanto el código fuente como las instrucciones de instalación están disponibles públicamente en GitHub .

Las funcionalidades soportadas son las siguientes:

• 480p, 720p y 1080p con 30 o 60 FPS.
• Aceleración de hardware de RaspberryPI 3 soporte para decodificar la secuencia de vídeo (hasta [email protected]).
• Reproducción de audio de todos los canales de audio (los medios de comunicación, sistema y discurso).
• Entrada de audio para comandos de voz.
• Pantalla táctil y soporte de botones de entrada.
• Bluetooth.
• Lanzamiento automático después de dispositivo hotplug.
• Detección automática de dispositivos Android conectados.
• Modo inalámbrico (WiFi) mediante servidor de unidad principal (debe estar habilitado en configuración desarrollador ocultos).
• Configuración fácil de usar.

Electrónica necesaria

Sin duda , aparte de la propia Rasberry Pi 3 , el display táctil es un componte fundamental en este proyecto. Con una resolución de 800×480 el modulo oficial de display +sensor se conecta a la Raspberry Pi 3 a través de una placa adaptadora que se encarga de controlar la alimentación y la señal de vídeo.

Solo se necesitan dos conexiones de la Raspberry Pi 3 : la alimentación desde el conector GPIO y el cable plano al conector DSI, presentes en todas las Raspberry.

El kit incluye:

• Pantalla 7″ multitáctil 10 puntos
• Placa conversara
• Cable plano DSI
• 4x tornillos para ajustar la Raspberry a la pantalla
• 4x cables para conectar la pantalla a la Raspberry

En el siguiente video se puede ver el proceso de montaje de este kit.

El controlador táctil ofrece 10 puntos de presión, por lo que el usar teclados en pantalla como el integrado en Raspbian lo hacen realmente sencillo.

Este kit convierte pues una Raspberry en una tableta multitáctil, sistema de información o dispositivo independiente.Es realmente interactivo pues la ultima version de Raspbian soporta teclado virtual en pantalla, así que no se necesita conectar un teclado y un ratón físicos ni por supuesto una pantalla externa.

Como podemos ver Android Auto se ejecuta en una Raspberry Pi 3 con la pantalla táctil oficial de 7 pulgadas anteriormente citada. Estos son los componentes esenciales para implementar este proyecto:

Raspvid

raspivid es la herramienta de línea de comandos para capturar vídeo con el módulo de cámara nativo de Raspberry. Con el modulo de cámara conectado y activado, se puede grabar un vídeo utilizando el siguiente comando:

Recuerde que debe utilizar y para voltear la imagen si es necesario, como con raspistill-hf-vf (esto guardara un archivo de vídeo 5 segundo en el camino dado aquí como (longitud por defecto de tiempo). vid.h264)

Para especificar la longitud del vídeo tomado, pase en la bandera con un número de milisegundos. Por ejemplo:-t Esto graba 10 segundos de video.)

Para una lista completa de las opciones posibles, ejecutar sin argumentos, o este comando a través de y desplácese a través de la pipa: raspividless

Utilice las teclas de flecha para desplazarse y el tipo de salida. q

Para ver la cámara trasera ejecutar raspvid seguido de los parámetros , como por ejemplo:

raspvid -t 5000 raspvid -t 0 raspvid -t -vh

raspvid -t 0 -vf ( invierte la imagen)

raspvid -t 0 -hf -vf

Instalar aasdk en Raspberri PI 3

Instalar el software necesario

$ sudo apt-get install -y libboost-all-dev libusb-1.0.0-dev libssl-dev cmake libprotobuf-dev protobuf-c-compilador protobuf compilador

Repositorio de aasdk clon

$ git clone -b master https://github.com/f1xpl/aasdk.git

Crear el directorio aasdk_build en el mismo nivel que aasdk dir

$ mkdir aasdk_build

$ cd aasdk_build

Generar archivos de cmake

$ cmake-DCMAKE_BUILD_TYPE = lanzamiento... /AASDK

Instalar el software necesario

$ sudo apt-get install -y libqt5multimedia5 libqt5multimedia5-plugins libqt5multimediawidgets5 qtmultimedia5-dev libqt5bluetooth5 libqt5bluetooth5-bin qtconnectivity5-dev pulseaudio librtaudio-dev librtaudio5a

$ cd /opt/vc/src/hello_pi/libs/ilclient

Repositorio de Open clon

$ git clone -b master https://github.com/f1xpl/openauto.git

$ mkdir openauto_build

$ cd openauto_build

Generar archivos de cmake

$ cmake-DCMAKE_BUILD_TYPE = liberación-DRPI3_BUILD = TRUE - DAASDK_INCLUDE_DIRS = "/ home/pi/aasdk/include"-DAASDK_LIBRARIES="/home/pi/aasdk/lib/libaasdk.so"-DAASDK_PROTO_INCLUDE_DIRS = "/ home/pi/aasdk_build"-DAASDK_PROTO_LIBRARIES = "usual PI/AASDK/lib/libaasdk_proto.so"... /openauto

$ /home/pi/openauto/bin/autoapp

Archivo abrir autostart

$ sudo nano /home/pi/.config/lxsession/LXDE-pi/autostart

@/ hogar/pi/Open/bin/autoapp

$ sudo nano /etc/udev/rules.d/openauto.rules

SUBSISTEMA == "usb", acción == "add", ENV {ID_VENDOR_ID} == "18d 1", ENV {ID_MODEL_ID} == "2d 00" RUN += "/ bin/sh - c ' / sbin/shutdown - c & & echo 0 > /sys/class/backlight/rpi_backlight/bl_power'"

SUBSISTEMA == "usb", acción == "add", ENV {ID_VENDOR_ID} == "18d 1", ENV {ID_MODEL_ID} == "2d 01", RUN += "/ bin/sh - c ' / sbin/shutdown - c & & echo 0 > /sys/class/backlight/rpi_backlight/bl_power'"

SUBSISTEMA == "usb", acción == "remove", ENV {ID_VENDOR_ID} == "18d 1", ENV {ID_MODEL_ID} == "2d 00" RUN += "/ bin/sh - c ' / sbin/shutdown: apagado 1 & & echo 1 > /sys/class/backlight/rpi_backlight/bl_power'"

SUBSISTEMA == "usb", acción == "remove", ENV {ID_VENDOR_ID} == "18d 1", ENV {ID_MODEL_ID} == "2d 01", RUN += "/ bin/sh - c ' / sbin/shutdown: apagado 1 & & echo 1 > /sys/class/backlight/rpi_backlight/bl_power'"

SUBSISTEMA == "usb", atributos {idVendor} == "*", atributos {idProduct} == "*", MODE = "0660", grupo = "plugdev"

$ cd /etc/udev/rules.d

$ sudo touch openauto.rules

$ sudo nano openauto.rules

resample-method = ffmpeg

load-module module-udev-detect tsched=0

Fuente https://github.com/f1xpl/openauto/wiki/Build-instructions

ELECTRÓNICA ADICIONAL

Para facilitar el manejo de openAuto y extender su funcionamiento Everlanders ha conectado 4 pulsadores directos para activar la cámara, variar el brillo o despertar la placa

No deja de ser importante el apartado de alimentación pues en la Raspberry Pi 3 es de 5v DC 2amp y en un automóvil es de 12V requiriéndose un convertidor dc-dc .Obviamente en los tiempos que correen ,es mucho mas eficiente un convertidor conmutado 12v-5v que un regulador 7805

También ,por ultimo para detectar la marcha atrás ,es muy interesante usar un opto-acoplador para aislar a la Raspberry Pi 3 de posibles problemas ele ctricos en el automovil dado el aislamiento galvánico que nos ofrecen los optoaisladores.

El esquema final de este montaje completamente opcional es el siguiente:

Para manejar los pulsadores se requieren los siguientes tres siguientes scripts escritos por el Everlands:

Este script en Python sirve para atenuar la pantalla y cambiar a la cámara de retroceso. Recuerde, que es interesante usar un optoacoplador para detectar la marcha atrás con los la lógica se invierte ... 0 = encendido 1 = apagado. Ademas, solo se debe ejecutar uno de estos scripts de "Monitor", es decir no puede estar ejecutando RearviewMonitor.py Y LightMonitor.py

CODIGO DE LIGTMONITOR.PY

#!/usr/bin/python

import RPi.GPIO as GPIO
import time
import subprocess, os
import signal
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
RearView_Switch = 14 # pin 18
Brightness_Switch = 15 # pin 16
#Extra_Switch = 1 # pin 3
GPIO.setup(RearView_Switch,GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(Brightness_Switch,GPIO.IN, pull_up_down=GPIO.PUD_UP)

print " Press Ctrl & C to Quit"

try:

# esto restringe la secuencia de comandos para verificar las luces cada 1/4 de segundo. #No tiene sentido revisar 10.000 veces por segundo.

# Si se encienden las luces de marcha atrás, hacer esto:
if GPIO.input(RearView_Switch)==0 and run == 0:
print "Switching Rearview Camera On"
rpistr = "raspivid -t 0 -vf -h 480 -w 800"
p=subprocess.Popen(rpistr,shell=True, preexec_fn=os.setsid)
run = 1

# Estos dos bloques siguientes monitorean los faros o la luz del marcador y ajustan la #configuración de brillo de la pantalla.

except KeyboardInterrupt:
print " Quit"
GPIO.cleanup()

Este script en cshell sirve par ajustar el nivel de luminosidad de la pantalla oficial qeu hemos conectado a la raspberry. Como es de esperar acepta un parámetro que es precisamente un entero entre 0 y 255

CODIGO SCRIPT BACKLIGHT

#!/bin/bash

level=$1
#echo "level given is $level"

if [[ $level -ge 0 & $level -le 255 ]]; then
#echo "level given is $level"
echo $level > /sys/class/backlight/rpi_backlight/brightness
echo "Screen brightness set to $level."
exit 0
else
echo "Brightness level $level is out of range! (0 to 255 only)"
exit 1
fi

Para probar el script de retro-iluminación ejecutar el script con el parámetro usando un valor entero menor que 255 ,por ejemplo ./backlight.sh 128

#!/usr/bin/python

import RPi.GPIO as GPIO
import time
import subprocess, os
import signal
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
RearView_Switch = 14 # pin 18
Brightness_Switch = 15 # pin 16
#Extra_Switch = 1 # pin 3
GPIO.setup(RearView_Switch,GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(Brightness_Switch,GPIO.IN, pull_up_down=GPIO.PUD_UP)

print " Press Ctrl & C to Quit"

try:

#los siguientes cuatro bloques se utilizan para alternar entre las vistas de la cámara.

if GPIO.input(RearView_Switch)==0 and run == 0:
print " Started Full Screen"
rpistr = "raspivid -t 0 -vf -h 480 -w 800"
p=subprocess.Popen(rpistr,shell=True, preexec_fn=os.setsid)
run = 1
while GPIO.input(RearView_Switch)==0:
time.sleep(0.1)

if GPIO.input(RearView_Switch)==0 and run == 1:
os.killpg(p.pid, signal.SIGTERM)
print " Started Full Screen Transparent"
rpistr = "raspivid -t 0 -vf -op 128 -h 480 -w 800"
p=subprocess.Popen(rpistr,shell=True, preexec_fn=os.setsid)
run = 2
while GPIO.input(RearView_Switch)==0:
time.sleep(0.1)

if GPIO.input(RearView_Switch)==0 and run == 2:
os.killpg(p.pid, signal.SIGTERM)
print " Started PIP Right side"
rpistr = "raspivid -t 0 -vf -p 350,1,480,320"
p=subprocess.Popen(rpistr,shell=True, preexec_fn=os.setsid)
run = 3
while GPIO.input(RearView_Switch)==0:
time.sleep(0.1)

# Estos tres bloques siguientes alternan entre las tres configuraciones de brillo.

except KeyboardInterrupt:
print " Quit"
GPIO.cleanup()

Respecto a la activación ,para probar la camara ejecutar ButtonMonitor.py. Ahora una vez probado , tenemos que hacer que se ejecute automáticamente . Para ello tenemos que editar el archivo /home/pi/.config/lxsession/LXDE-pi/autostart

En la ultima linea del script añadir /usr/local/bin/ButtonMonitor.py

IMPORTANTE : Deberemos copiar los tres scripts a la ruta /usr/local/bin y conceder los permisos de ejecución mediante el comando sudo chmod +x . La fuente original de los scripts es : https://gist.github.com/Everlanders

En el siguiente vídeo podemos ver todo el proceso de creación de un dispositivo basado en Raspberry PI para uso exclusivo en un vehículo usando todos los componentes mencionados anteriormente.