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:

raspivid -o vid.h264

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 raspivid -o video.h264 -t 10000  (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

raspivid 2>&1 | less

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

  1. Instalar el software necesario

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

  1. Repositorio de aasdk clon

$ cd

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

  1. Crear el directorio aasdk_build en el mismo nivel que aasdk dir

$ mkdir aasdk_build

$ cd aasdk_build

  1. Generar archivos de cmake

$ cmake-DCMAKE_BUILD_TYPE = lanzamiento… /AASDK

  1. Construir aasdk

$ make

Instalar el resto de sw en Raspberry PI 3

  1. Instalar el software necesario

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

  1. Construir ilclient de frambuesa PI 3 firmware

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

$ make

  1. Repositorio de Open clon

$ cd

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

  1. Crear el directorio openauto_build en el mismo nivel que Open dir

$ mkdir openauto_build

$ cd openauto_build

  1. Generar archivos de cmake

Nota: Si es necesario, ajustar los path  a su localización de directorios aasdk y aasdk_build.

$ cmake -DCMAKE_BUILD_TYPE=Release -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=”/home/pi/aasdk/lib/libaasdk_proto.so” ../openauto

  1. Construir OpenAuto

$ make

  1. Ejecutar Open

$ /home/pi/openauto/bin/autoapp

Añadir Open a autorun

  1. Archivo abrir autostart

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

  1. Agregar debajo de línea al final del archivo autorun

@/ hogar/pi/Open/bin/autoapp

 

Apagar  Raspbery PI 3 cuando el teléfono se está desconectando

  1. Archivo abierto openauto.rules

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

  1. Añadir a continuación las líneas al final del archivo 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'”

Este  script va a hacer las siguientes acciones:

  1. Desactivar el apagado de pantalla y programar de forma  retrasada  por 1 minuto cuando el teléfono se está desconectando
  2. Encender la pantalla y cancelar el apagado cuando el teléfono se está conectando

Puede ajustarse el  retraso de 1 minuto para sus necesidades.

 

Reglas de udev (permisos de USB)

Para utilizar Open con sistema operativo basado en Linux (por ejemplo, Raspbian) con udev, debe crear una regla para permitir la comunicación con los dispositivos USB en modo de lectura/escritura.

La regla más simple parece debajo de uno:

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

Para agregar esta regla de udev, hacer:

$ cd /etc/udev/rules.d

$ sudo touch openauto.rules

$ sudo nano openauto.rules

Aplique estas reglas, guarde el archivo y reinicie el dispositivo.

Tenga en cuenta que la regla anterior permite  abrir cualquier dispositivo USB en modo de lectura/escritura por cualquier aplicación instalada en el sistema. Considerar como insegura.

Configuración de PulseAudio

Paquetes audio de AndroidAuto se entregan en trozos muy pequeños. Debido a esto podrían necesitarse ajustes de configuración de PulseAudio para evitar problemas con el audio.

Añadir/anulación por debajo de las líneas en /etc/pulse/daemon.conf

resample-method = ffmpeg

En /etc/pulse/default.pa añadir tsched = 0 en la línea de ‘carga-módulo módulo-udev-detect’

load-module module-udev-detect tsched=0

Después de cambios de configuración debe reiniciar la instancia de pulseaudio. Puede hacerlo con  la ejecución del comando  pulseaudio -k .

 

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:

esquema.PNG

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

LightMonitor.py

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:

run = 0
bright = 0
while True :
time.sleep(0.25)

# 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

Cuando las luces de marcha atrás se apagan, hacer esto:

if GPIO.input(RearView_Switch)==1 and run == 1:
os.killpg(p.pid, signal.SIGTERM)
print “Killing the reverse camera feed”
run = 0

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

if GPIO.input(Brightness_Switch)==0 and bright == 0:
print “Setting Brightness to 20” # 20 is about 10%
subprocess.call (“/usr/local/bin/backlight.sh 20”, shell=True)
bright = 1

if GPIO.input(Brightness_Switch)==1 and bright == 1:
print “Setting Brightness back to 255” #255 is 100%
subprocess.call (“/usr/local/bin/backlight.sh 255″, shell=True)
bright = 0

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

 

backlight.sh

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 [ $# != 1 ]; then
echo “USAGE: $0 brightness_level (0 to 255)”
exit 1
fi

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

 

ButtonMonitor.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:

run = 0
bright = 0
while True :
time.sleep(0.1)

#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)

if GPIO.input(RearView_Switch)==0 and run == 3:
print ” Stopped ”
run = 0
os.killpg(p.pid, signal.SIGTERM)
while GPIO.input(RearView_Switch)==0:
time.sleep(0.1)

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

if GPIO.input(Brightness_Switch)==0 and bright == 0:
print “Setting Brightness to 255”
subprocess.call (“/usr/local/bin/backlight.sh 255”, shell=True)
bright = 1
while GPIO.input(Brightness_Switch)==0:
time.sleep(0.1)

if GPIO.input(Brightness_Switch)==0 and bright == 1:
print “Setting Brightness to 128”
subprocess.call (“/usr/local/bin/backlight.sh 128”, shell=True)
bright = 2
while GPIO.input(Brightness_Switch)==0:
time.sleep(0.1)

if GPIO.input(Brightness_Switch)==0 and bright == 2:
print “Setting Brightness to 20”
subprocess.call (“/usr/local/bin/backlight.sh 20”, shell=True)
bright = 0
while GPIO.input(Brightness_Switch)==0:
time.sleep(0.1)

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

autostart.PNG

 

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.

 

Anuncios

Sencilla cámara trasera basada en Android


Las cámaras de atrás para  vehículos son sin duda una pieza fundamental en materia de seguridad , pues además  de ser muy  útiles para aparcar  se han demostrado  que son muy necesarias para reducir accidentes mientras transmiten una  imagen mas real de la parte atrás del vehículo  sin ángulos muertos  hacia el conductor .

Tal es su utilidad  que desde 2014 se requieren en todos los coches nuevos en los Estados Unidos, aunque  en Europa y Sudamérica aun todavía no es obligatorio, aunque muchos fabricantes incluso en gamas económicas lo incluyen  de serie .

Su su coche no dispone de cámara trasera , se puede hacer un sistema de relativamente bajo costo del mercado con muy poca inversión.

Aunque existen muchísimas  soluciones vamos  a ver tres bastante económicas:

Usar un  smartphone como cámara

En efecto, dado la potencia  y versatilidad de los smartphones actuales , realmente pueden usarse perfectamente estos  como cámaras IP portátiles , eso si ,  siempre que el smartphone que hace cámara y el smartphone que hace de visor  estén en la misma red, para lo cual puede ser muy interesante automatizar el proceso  como vimos en este post

Vamos a ver algunas aplicaciones para  tal cometido:

FreeRear ViewCam

Es una app que contiene publicidad donde el teléfono inteligente actual se utiliza como un monitor cerca del conductor y su “viejo terminal “, sin uso encuentra su lugar “atrás” y utiliza la funcionalidad de la cámara. A través de la aplicación, los dos teléfonos inteligentes están acoplados, la cámara de la “vieja” y el monitor de los “nuevos” teléfonos – que es la cámara trasera.
Como aspecto negativo la cámara de marcha y la función de grabación contiene publicidad  (hay que pagar  una pequeña cuota para anularlo en la versión avanzada).
Una versión Pro con características especiales está previsto para el futuro.

Es importante destacar que  la transmisión del flujo de vídeo consume  batería  fuertemente, en particular la de los teléfonos con cámara. Si desea transmitir un tiempo más largo conecte el teléfono a una fuente de alimentación y / o Apágala después de su uso.

Advertir a los usuarios de termimales SAMSUNG que el desarrollador  desaconseja el uso de dispositivos de Samsung con FreeRearviewCam. Debido a que una aplicación individual de directrices Android cualquier reconexión entre el transmisor y el receptor móvil requiere una nueva validación en el teléfono transmisor., lo cual o significa que el usuario durante cada nuevo uso de la aplicación en el coche debe  dar permiso para enviar :

Esta app utiliza FFmpeg para el procesamiento de vídeo. Se llama a un FFmpeg binario precompilado como proceso externo. Puede encontrar el código fuente utilizado para compilar el FFmpeg través https://www.freerearviewcam.com/ffmpeg

Los pasos para usar esta app son bien sencillos:

  • Descargar e instalar la app  en los dos terminales  desde  Google Play

Captura de pantalla

  • Ambos  terminales deben estar conectados por wifi a la misma red.
  • Pulsar Back Camara  en el terminal que va a hacer de cámara.
  • Pulsar Front Monitor en el terminal que va a hacer de visor :en unos segundos deberíamos ver en el terminal la imagen captada por la cámara.

IP Webcam

Esta app es muy similar la anterior  debiéndose usar  la misma app para ambas funciones : camera o visor.

Tan solo hay una diferencia con la pp anterior  y es el hecho de generar un token desde la cámara , que deberá ser introducida en el visor.

Captura de pantallaCaptura de pantallaCaptura de pantallaCaptura de pantallaCaptura de pantalla

Esta app en realidad no es para coche  pues utiliza el teléfono Android como cámara web, convirtiendo  un teléfono inteligente en  una cámaras de seguridad para el hogar, es decir una cámara de red  que  permite  ver la cámara en cualquier lugar , pero en realidad  puede servir para monitorizar también la vista trasera del coche
Lo que esta claro es que esta app transforma un  antiguos teléfono inteligente en una cámara ip , que puede usarse como  sistema de seguridad para el hogar, vigilando y protegiendo tu casa, cámara para mascotas, monitor de bebé,o cámara de coche

Este es el link en Google Play https://play.google.com/store/apps/details?id=nfo.webcam

Por cierto una app “profesional” similar a las dos anteriores,  y que puede  usarse no solo como cámara de vigilancia sino cámara trasera para coche, es la famosa aplicación de cámara de vigilancia wifi de Alfred Labs (https://play.google.com/store/apps/details?id=com.ivuu)

Otra solución : una cámara IP

Hemos hablado de cámaras wifi con terminales android , pero también existen camaras IP especificas para coche  y que nos van a permitir    visionar en nuestro terminal android la imagen captada por estas de un modo mas funcional y útil que una pantalla especifica.

La cámara opera  a  2.3-2.4ghz, Velocidad de fotogramas de 30 fps; rango de transmisión de 20 pies a 60 pies (hasta 100 pies bajo ninguna otra condición de obstáculo).

Esta camara  IP  es impermeable, a prueba de polvo y a prueba de choques; iluminación mínima del soporte menos de 0.5 señal digital del lux,de modo que usted podría conseguir una imagen clara incluso en la noche.

Es muy fácil de instalar y operar:

  1. Conecte el transmisor wifi y la cámara trasera a la luz de reserva o alimentación de 9V-30V,
  2. Descargue la aplicación “WIFIAV” en su teléfono (dispositivo inteligente) desde Google Play Store
  3. Instale la aplicación gratuita WiFiAV .
  4. Puede utilizar  el nombre predeterminado del dispositivo (WiFiAV) y la contraseña predeterminada (12345678), pero se puede personalizar con un nuevo nombre y contraseña de la manera que se desee.Hay un botón en el transmisor que reiniciará el transmisor a este valor predeterminado en caso de que cambie las cosas y olvide su nueva contraseña
  5. Obtenga una señal de imagen

Esta cámara   tampoco sirve para Samsung J7 S7 S8 pero soporta iPhone, iPad  auqnue no es compatible con la versión del teléfono que está por debajo de 4.0.

La pantalla de la aplicación llena toda la pantalla, pero puedes pellizcarla y arrastrarla para ajustarla a tu gusto. aproximadamente 3/4 de la pantalla para que sea realmente clara y nítida y  como novedad implementa lineas  de referencia.

.Captura de pantalla

El precio es lo único que nos puede disuadir  ; unos 62,99€ en Amazon pues por lo demás no nos  parece una mala opción.

Tercera solución; Rasberry pi con camara

Ya  que hemos hablado de usar un terminal Android o una cámara especifica ¿por que no usar nuestro propio hw?  Pues en efecto se puede gracias a la aplicación RearPi de la que hablaremos en un próximo post.