Monitorizar el espacio aereo con software libre, una Rasberry PI y un receptor ADS-B

yayitazale
May 15, 2022
- Diy

Probablemente ya conozcas los servicios como FlightRadar24, FlightAware, PlaneFinder etc. En contra de lo que la mayoría de la gente piensa, estos servicios se nutren en gran parte por los datos publicados por aficionados a la aviación que captan las señales abiertas ADS-B que emiten los aviones y los envían a estos servicios. Gran parte de lo que os voy a contar lo he aprendido a partir de este post de Reddit.

En el post de hoy vamos a aprender a poner en marcha un sistema que nos permitirá ver las posiciones de los aviones en un mapa y enviar estos datos a los servicios que he comentado. Aquí puedes ver mi instalación actual funcionando. (Foto de portada Philip Myrtorp en Unsplash)

Materiales

Lo primero que tenemos que saber es que tendremos que colocar una antena en el exterior, a ser posible en la azotea de nuestro edificio en un punto lo más elevado posible y sin elementos que nos limiten la recepción de la señal. Si tenemos la posibilidad de poner la antena en una posición con 360º de visión al cielo es lo ideal. En mi caso, tengo una posición bastante elevada por lo que la antena la he colocado en lo alto de la terraza, con una visión de unos 300º sin obstáculos.

En segundo lugar tenemos que tener en cuenta que dado que la antena se coloca en el exterior, deberemos o bien llevar la señal de la antena hasta donde podamos poner el equipo informático con el cual transformar esta señal de la antena. Si disponemos de un servidor UnRaid, podemos utilizar este mismo llevando el cable de la antena hasta el mismo.

En mi caso, como esto sería muy fácil de hacer, he decidido utilizar el enchufe que ya tengo en la terraza y meter una Raspberry Pi en una caja estanca, de manera que toda la instalación queda en el exterior.

Dicho esto, los materiales utilizados en mi caso son (referidos):

Raspberry Pi 3 model b, no hay stock en ninguna parte, supongo que tendrás una el cajón… En cualquier caso, podrías utilizar cualquier model 3 o 4 incluso una zero.
Fuente alimentación para la Raspberry Pi
Tarjeta MicroSD aunque con 16Gb nos vale también
Antena específica para frecuencia 1090 MHz con un cable largo
Receptor USB ADB-S RTL
Filtro 1090MHz de tipo paso banda
Un latiguillo macho-hembra SMA para conectar el filtro con el receptor
Caja estanca de exterior IP55
Un paquete de bridas para fijar los cables

Para la colocación de la antena en mi caso he optado por imprimir en 3D un soporte de antena ya que los que trae solo sirven para fijarlo en barandillas etc.

Preparar la Raspberry PI

Lo primero que vamos a hacer es descargarnos el Raspberry Pi Imager e instalarlo en nuestro PC. Cuando lo tengamos instalado, insertamos la tarjeta micro SD y seleccionamos la imagen Raspberry PI OS LITE (yo os recomiendo la versión de 64 bit que podéis encontrar bajo el menú Raspberry PI OS (other) ya que es muy estable y le gana por goleada en rendimiento a la versión de 32 bit:

Seleccionamos nuestra SD y le damos a la rueda de configuración (advanced options):

Aquí tendremos que hacer varias cosas:

Fijamos un hostname, por ejemplo planes.local
Habilitamos el SSH vía contraseña
Creamos un usuario/contraseña
Configuramos también la WiFi

De esta forma, cuando arranquemos el equipo ya tendremos todo listo y nos podremos conectar a equipo de forma remota sin necesitad de conectarlo a una pantalla/teclado/ratón. Ahora sí, cerramos las opciones avanzadas y le damos a writte para que se cree nuestro SO en la SD. Cuando termine de escribir, metemos la tarjeta SD en la RPI y la encendemos.

SSH y Docker

Para conectarnos por SSH tenemos varias opciones. La más sencilla es utilizar Putty, aunque si has seguido los pasos de mi anterior post, puedes añadir este equipo a tu Guacamole y acceder a la consola vía web con los datos que as fijado en las opciones avanzadas:

Hostname
User/pass

Una vez conectados al equipo, como siempre lo primero es actualizarlo con el siguiente comando:

sudo apt-get update && sudo apt-get upgrade –y

Cuando termine, instalaremos docker con los siguientes comandos:

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

Montaje de los equipos

El montaje del hardware es sencillo.

Coloca la antena, como hemos dicho, en el lugar más elevado que puedas y con la vista al cielo lo más despejada posible
Fija la caja estanca en la pared donde vayas a colocarlo y lleva la corriente eléctrica hasta la dentro de la misma
Lleva el cable de la antena hasta dentro de la caja estanca
Conecta el filtro al cable de la antena
Usando el latiguillo, conecta el filtro con el receptor USB
Enchufa el receptor a uno de los puertos USB de la RPI
Conecta la fuente de alimentación a la RPI
Cierra la caja

Si todos los pasos son correctos deberías poder volver a conectarte a la RPI por SSH.

Levantar el servicio

El servicio que vamos a utilizar es el de Thom-X. Las configuraciones que podemos utilizar son diversas, por lo que te animo a que le eches un ojo a su repositorio donde encontrarás los pasos concretos de cada instalación. En mi caso, voy a utilizar los siguientes módulos:

Dump1090 para visualizar las señales recibidas en un mapa propio
Open Weather Map layers para que aparezcan las nubes de la zona (que afectan a la calidad y cantidad de las señales recibidas)
Terrain-limit rings para dibujar el contorno de máximo alcance debido al horizonte sobre el mapa
FR24feed para subir datos a FR24 (te dan una cuenta bussines gratis)
PIAware para subir datos a FlightAware (te dan una cuenta premium gratis)
MLAT para que los servicios antes comentados puedan triangular la posición exacta de los aviones conociendo la posición exacta de las estaciones

Vamos a ir por partes. Lo primero que vamos a hacer es conocer nuestra ubicación y altitud exacta usando MapCoordinates. Con estos datos vamos a arrancar el servicio con el siguiente comando cambiando los valores de latitud, longitud y altitud. Como puedes ver, hay que meterlos dos veces. Los valores de MLAT deben ser los reales, pero en los valores HTML podemos poner unos diferentes ya que solo sirven para centrar el mapa en la visualización. De esta forma, si queremos tener la página accesible desde el exterior no estaríamos publicando la ubicación real de la antena.

docker run -d -p 8080:8080 -p 8754:8754 --name dump\
 --device=/dev/bus/usb:/dev/bus/usb \
 -v "/etc/localtime:/etc/localtime:ro" \
 -e "HTML_SITE_LAT=MY_SITE_LAT" \
 -e "HTML_SITE_LON=MY_SITE_LON" \
 -e "HTML_SITE_NAME=MY_SITE_NAME" \
 -e "MLAT_EXACT_LAT=MY_EXACT_SITE_LAT" \
 -e "MLAT_EXACT_LON=MY_EXACT_SITE_LON" \
 -e "MLAT_ALTITUDE_MSL_METERS=MY_SITE_ALT_MSL_METERS" \
 --tmpfs /run:exec,size=32M \
 thomx/fr24feed-piaware

Cuando arranque, si accedemos por el navegador a nuestro hostname, yo he puesto planes.local:8080 podremos empezar a visualizar la posición de los aviones que capta nuestra antena:

Ahora vamos a preparar los datos de OWM y heywhatsthat. En el primero, simplemente debes crearte una cuenta en su web (puede que ya la tengas si seguiste los pasos del post del riego inteligente) y crear una API KEY dentro de cuenta. En el segundo, vamos a new panorama y usando los datos de latitud, longitud y altitud que hemos obtenido antes, realizaremos una solicitud. Cando esté listo nos llegará un link al panorama tipo http://www.heywhatsthat.com/?view=XXXX del cual cogeremos solo la parte final como ID del panorama.

Ahora, en la consola de RPI hacemos

sudo docker stop dump
sudo rm dump

Y lanzamos de nuevo el servicio pero añadiendo estos dos nuevos elementos:

docker run -d -p 8080:8080 -p 8754:8754 --name dump\
 --device=/dev/bus/usb:/dev/bus/usb \
 -v "/etc/localtime:/etc/localtime:ro" \
 -e "HTML_SITE_LAT=MY_SITE_LAT" \
 -e "HTML_SITE_LON=MY_SITE_LON" \
 -e "HTML_SITE_NAME=MY_SITE_NAME" \
 -e "PANORAMA_ID=MY_PANORAMA_ID" \
 -e "LAYERS_OWM_API_KEY=MY_OWM_API_KEY" \
 -e "MLAT_EXACT_LAT=MY_EXACT_SITE_LAT" \
 -e "MLAT_EXACT_LON=MY_EXACT_SITE_LON" \
 -e "MLAT_ALTITUDE_MSL_METERS=MY_SITE_ALT_MSL_METERS" \
 --tmpfs /run:exec,size=32M \
 thomx/fr24feed-piaware

Si todo va bien podremos activar en la visualización de nuestra web planes.local:8080 la capa de OWM y los límites del terreno:

PiAware feeder

Para activar la subida de datos a FlightAware los pasos son:

Create una cuenta en https://flightaware.com/account/join/

Ahora lanzamos el siguiente comando:

docker run -it --rm \
 -e "SERVICE_ENABLE_DUMP1090=false" \
 -e "SERVICE_ENABLE_HTTP=false" \
 -e "SERVICE_ENABLE_FR24FEED=false" \
 -e "SERVICE_ENABLE_PIAWARE=false" \
 thomx/fr24feed-piaware /usr/bin/piaware -plainlog

Al arrancar nos aparecera un feeder-id, lo apuntamos. Esperamos unos 5 minutos y entramos desde el navegador a https://fr.flightaware.com/adsb/piaware/claim y aquí hacemos “claim”.

En la consola de la RPI hacemos ctrl+C para salir del contenedor que acabamos de crear.

Ahora borramos el contenedor principal:

sudo docker stop dump
sudo rm dump

Y lo volvemos a levantar esta vez añadiendo el feeder-id de PiAware:

docker run -d -p 8080:8080 -p 8754:8754 --name dump\
 --device=/dev/bus/usb:/dev/bus/usb \
 -v "/etc/localtime:/etc/localtime:ro" \
 -e "PIAWARE_FEEDER_DASH_ID=MY_FEEDER_ID" \
 -e "HTML_SITE_LAT=MY_SITE_LAT" \
 -e "HTML_SITE_LON=MY_SITE_LON" \
 -e "HTML_SITE_NAME=MY_SITE_NAME" \
 -e "PANORAMA_ID=MY_PANORAMA_ID" \
 -e "LAYERS_OWM_API_KEY=MY_OWM_API_KEY" \
 -e "MLAT_EXACT_LAT=MY_EXACT_SITE_LAT" \
 -e "MLAT_EXACT_LON=MY_EXACT_SITE_LON" \
 -e "MLAT_ALTITUDE_MSL_METERS=MY_SITE_ALT_MSL_METERS" \
 --tmpfs /run:exec,size=32M \
 thomx/fr24feed-piaware

FlightRadar24 feeder

Para activar la subida de datos de FR24 los pasos son similares. Lanzamos un contenedor con el siguiente comando:

docker run -it --rm \
 -e "SERVICE_ENABLE_DUMP1090=false" \
 -e "SERVICE_ENABLE_HTTP=false" \
 -e "SERVICE_ENABLE_PIAWARE=false" \
 -e "SERVICE_ENABLE_FR24FEED=false" \
 thomx/fr24feed-piaware /bin/bash

Y luego:

/fr24feed/fr24feed/fr24feed --signup

y sigue las instrucciones, para los pasos técnicos, tu respuesta no importa solo necesitamos la clave de intercambio al final.

Cuando acabe el formulario hacemos

cat /etc/fr24feed.ini

Y anotamos el sharing key. Salimos del contenedor haciendo ctrl+C.

Volvemos de nuevo a borrar el contenedor principal:

sudo docker stop dump
sudo rm dump

Y lo relanzamos con los ID de PiAware y FR24 y añadiendo restart=always para que nunca se pare:

docker run -d -p 8080:8080 -p 8754:8754 --name dump\
 --device=/dev/bus/usb:/dev/bus/usb \
 -v "/etc/localtime:/etc/localtime:ro" \
 -e "FR24FEED_FR24KEY=MY_SHARING_KEY" \
 -e "PIAWARE_FEEDER_DASH_ID=MY_FEEDER_ID" \
 -e "HTML_SITE_LAT=MY_SITE_LAT" \
 -e "HTML_SITE_LON=MY_SITE_LON" \
 -e "HTML_SITE_NAME=MY_SITE_NAME" \
 -e "PANORAMA_ID=MY_PANORAMA_ID" \
 -e "LAYERS_OWM_API_KEY=MY_OWM_API_KEY" \
 -e "MLAT_EXACT_LAT=MY_EXACT_SITE_LAT" \
 -e "MLAT_EXACT_LON=MY_EXACT_SITE_LON" \
 -e "MLAT_ALTITUDE_MSL_METERS=MY_SITE_ALT_MSL_METERS" \
 --tmpfs /run:exec,size=32M \
 --tmpfs /usr/lib/fr24/public_html/data:size=32M \
 --restart=always \
 thomx/fr24feed-piaware

Finalmente para que docker arranque al inicio hacemos:

sudo systemctl enable docker

Final

Con esto ya tendriamos los servicios funcionando y subiendo datos a ambas webs. El único paso pendiente sería el de publicar la web de tu receptor al público, algo totalmente opcional y que puedes hacer sigueindo los pasos del post Selfhosted SaaS seguro con reverse proxy y TLS. Solo debes apuntar al hostname y puerto 8080 de la RPI como he hecho yo.