Escribiendo Aplicaciones MAVSDK/PX4 Para Drones

Escrito por Raúl Alvarez.

Autor: Raúl Alvarez-Torrico

Esta es una traducción automática (pueden haber algunos errores de traducción) de mi artículo original en inglés publicado por la revista "Circuit Cellar" (#361 de Agosto, 2020). El código de programa y diagramas aún están en Inglés.

Resumen

En este artículo comparto una introducción rápida al desarrollo de aplicaciones para drones con la librería MAVSDK MAVLink y el ecosistema de autopiloto PX4. Hablo acerca de cómo configurar el entorno de desarrollo en el sistema operativo Ubuntu instalando una cadena de básica de herramientas que incluye la pila de vuelo PX4 "Software In The Loop" (SITL) junto con los simuladores jMAVSim y Gazebo, además de MAVSDK-Python (el "wrapper" de Python a la librería MAVSDK escrita en C++) y software de estación de control de tierra QGroundControl. Luego, explico cómo escribir tu primera aplicación de vuelo autónomo para un cuadrirotor mostrando un ejemplo en el que el vehículo básicamente sigue una ruta predeterminada para escribir las iniciales de tu nombre en el aire. La simulación Software In The Loop (SITL) se utiliza para probar el ejemplo, pero también explico brevemente cómo ejecutarlo con un dron real.

Este artículo es una continuación de mi artículo anterior de dos partes "Introducción a Ardupilot y PX4" y, aunque está destinado a principiantes que nunca experimentaron con vuelo autónomo de drones y/o la librería MAVSDK, requerirá que tengas al menos conocimiento introductorio general sobre cómo funcionan los cuadricópteros, el ecosistema de software del controlador de vuelo PX4, incluyendo el protocolo MAVLink y QGroundControl, y, por supuesto, el lenguaje de programación Python. Consulta mi artículo anterior de dos partes "Introducción a Ardupilot y PX4" para una introducción general a los cuadrirotores y la plataforma PX4.

Videos

Actual. Ubuntu, Instalación Guest Additions

Demo App Vuelo Autónomo Drone	Introducción	Descarga VirtualBox y Ubuntu 18.04

Instalación Ubuntu 18.04 en VirtualBox	Actual. Ubuntu, Instalación Guest Additions	Instalación PX4 SITL con jMAVSim y Gazebo

Si los videos no están visibles en esta página, puedes verlos directamente en nuestro canal de YouTube.

1. Demo App Vuelo Autónomo Drone
2. Introducción
3. Descarga VirtualBox y Ubuntu 18.04
4. Instalación Ubuntu 18.04 en VirtualBox
5. Actual. Ubuntu, Instalación "Guest Additions"
6. Instalación PX4 SITL con jMAVSim y Gazebo
7. Compilación de PX4 SITL con jMAVSim (muy pronto)*
8. Compilación de PX4 con Gazebo (muy pronto)*
9. Corriendo Ejemplos Básicos de MAVSDK (muy pronto)*
10. Corriendo el ejemplo "write_my_initials.py" (muy pronto)*

* Suscríbete a nuestro boletín para recibir noticias

Entorno de Desarrollo

Los sistemas operativos Mac OS, Linux y Windows son oficialmente soportados para el desarrollo con PX4. Después de probar la instalación de la cadena de herramientas en Windows y Linux (desafortunadamente no en Mac OS), descubrí que Windows no es realmente recomendable para principiantes porque el proceso de instalación puede ser engorroso, a menos que tengas experiencia previa en la configuración de entornos de compilación en Windows. Por otro lado, la instalación de Linux parece ser más fácil y con un mejor soporte oficial; aparentemente Linux se usa ampliamente como plataforma preferida para el desarrollo con PX4. El ejemplo preparado especialmente para este artículo se probó en Ubuntu 18.04, tanto de forma nativa como en una máquina virtual usando VirtualBox en un host Windows. También debería funcionar en Ubuntu 16.04. Por otro lado, hay disponible un contenedor Docker con la cadena de herramientas de desarrollo instalada de antemano; aunque al momento de escribir este artículo, solo es compatible con Linux.

Instalación de la Cadena De Herramientas

En los siguientes párrafos describiré cómo instalar la cadena de herramientas de desarrollo en Ubuntu 18.04. Incluirá la pila de vuelo PX4 SITL con los simuladores jMAVSim y Gazebo, la librería MAVSDK-Python y el software de la estación de tierra QGroundControl. No explicaré minuciosamente todos los pasos involucrados; sin embargo, hay un archivo de texto llamado "INSTALL_RUN_SIMULATION.md" incluido con el código fuente de este artículo que describe todos los pasos que tomé para instalar la cadena de herramientas y también contiene enlaces a las páginas oficiales de PX4 explicando los procedimientos detallados.

Si solo tienes una máquina Windows a mano, puedes usar VirtualBox para crear una máquina Linux Ubuntu virtual dentro de Windows. Consulta la sección "Recursos" para ver algunos enlaces web recomendados sobre herramientas, procedimientos y conceptos descritos en este artículo. Una vez que tengas listo tu sistema operativo Ubuntu, sigue estos pasos para configurar la cadena de herramientas de desarrollo:

Primero, instala el entorno de simulación PX4 SITL jMAVSim/Gazebo (podrías necesitar instalar algunas librerias como requisitos previos, consulta el archivo de texto 'INSTALL_RUN_SIMULATION.md' para ver los pasos detallados). Una vez completada la instalación, el procedimiento te dejará en el subdirectorio de compilación predeterminado, que es "~/src/Firmware". Desde este subdirectorio puedes compilar y ejecutar la pila de vuelo PX4 SITL con los simuladores de vehículos jMAVSim y Gazebo. Por ejemplo, para compilar y ejecutar PX4 SITL con Gazebo, en la misma terminal de comando ejecuta make px4_sitl gazebo. Es posible que la compilación falle debido a la falta de algunas librerías pre-requisito que no tienes instaladas en tu sistema Ubuntu, consulta el archivo "INSTALL_RUN_SIMULATION.md" para consejos acerca de cómo solucionar algunos errores de compilación que puedas obtener.

Una vez que la compilación finalice sin errores, el simulador Gazebo se iniciará y mostrará un quadricóptero 3DR Iris+ simulado (Ver Figura 1). En la misma terminal de comando, ejecuta commander takeoff y verás que el dron comienza a despegar a una altitud predeterminada. En algunos casos, el quadricóptero aterrizará por sí solo después de unos segundos, de lo contrario, ejecuta commander land para que aterrice en su posición inicial de despegue. Para detener la simulación, presiona <Ctrl + c> en la terminal de comandos. También puedes probar PX4 SITL con el simulador jMAVSim ejecutando make px4_sitl jmavsim. La Figura 2 muestra la simulación jMAVSim después de que ejecutar commander takeoff.

Figura 1: PX4 SITL con simulador Gazebo

Figura 2: PX4 SITL con simulador jMAVSim

A continuación, instala MAVSDK-Python; descarga e instala QGroundControl y clona el repositorio GitHub de MAVSDK-Pythonpara ejecutar los ejemplos que se describen a continuación. Estos últimos pasos son muy sencillos, consulta el archivo "INSTALL_RUN_SIMULATION.md" para obtener más detalles. Si lograste llegar a este punto, ¡estás listo para probar un código de Python para hacer que el quadricóptero vuele solo!

Ejecutando Ejemplos Básicos

Probemos algunos ejemplos del repositorio MAVSDK-Python que acabamos de clonar. Primero, haz correr uno de los dos simuladores (por ejemplo, puedes ejecutar make px4_sitl gazebo). En segundo lugar, haz correr el software de la estación de control de tierra QGroundControl. Tercero, abre otra ventana de terminal de comandos y ejecuta cd ~/MAVSDK-Python/examples para ir al directorio de ejemplos de MAVSDK-Python (suponiendo que clonaste MAVSDK-Python en tu directorio de inicio "home"). A continuación, ejecuta python3 takeoff_and_land.py para correr el ejemplo "despegar y aterrizar". Deberías ver que el quadricóptero despega y luego aterriza automáticamente después de unos segundos. La Figura 3 muestra este ejemplo en ejecución. Si esto funcionó bien para ti, entonces tienes la cadena de herramientas instalada correctamente.

Figura 3: Ejemplo 'takeoff_and_land.py' corriendo

De manera similar, también puedes probar el ejemplo "offboard_position_ned.py"; éste le da al dron algunas coordenadas de navegación en su sistema de coordenadas local. Ejecuta el comando python3 offboard_position_ned.py para probar este ejemplo también.

Sistema de Coordenadas "NED"

Si revisas el código para el ejemplo 'offboard_position_ned.py', notarás que las líneas de código encargadas de comandar el dron a una determinada pose se ven así:

wait drone.offboard.set_position_ned (PositionNedYaw (5.0, 10.0, -5.0 , 90.0))

La función 'set_position_ned ()' se usa para comandar al dron y los argumentos que recibe son coordenadas en el sistema de coordenadas "North, East, Down" (NED) o "Norte, Este, Abajo" en Español. Entonces, el primer número en el argumento (5.0) es la distancia a lo largo del eje Norte, el segundo número (10.0) es la distancia a lo largo del eje Este y el tercer número (-5.0) es la altitud. Si la altitud es negativa, significa que el dron en realidadsubirá, porque en NED, "Down -5.0" es realmente "Up +5.0" (Arriba +5.0). La altitud y las distancias están en metros.

El cuarto número (90.0) es el ángulo de orientación deseado en grados para el dron cuando éste alcanza la posición deseada. El ángulo de orientación es el ángulo alrededor del eje vertical del dron, conocido también como el ángulo "Yaw" (ángulo de "guiñada"). Por lo tanto, la función "PositionNedYaw()" tomará estos cuatro números como argumentos y los convertirá en una estructura de datos de tipo "PositionNedYaw"; definida y utilizada en librería MAVSDK para poses en el sistema de coordenadas NED. NED y otra variante llamada ENU ("East, North, Up") son dos sistemas de coordenadas geográficas locales que se utilizan para la navegación de aeronaves. Tienen sus ejes orientados a lo largo de las direcciones geodésicas definidas por la superficie de la Tierra, con sus orígenes fijos en el centro de gravedad de la aeronave [Referencia 1]. Ambos siguen la regla de la "mano derecha".

Programación Asíncrona en Python

Otra característica que también vale la pena señalar en los ejemplos que acabamos de ejecutar es el uso de la librería Python "asyncio" con sus palabras reservadas "async/await" correspondientes. Incluso si programaste en Python antes, existe la posibilidad de que nunca hayas usado la librería de programación asincrónica "asyncio". Cuando se usa esta librería, la palabra clave async nos permite declarar una función "asincrónica", típicamente llamada "corutina". Una corutina es básicamente una función cuya ejecución puede pausarse en algún momento; generalmente para esperar algún evento o datos de los cuales depende su ejecución posterior. En otras palabras, las funciones asincrónicas pueden detenerse para esperar algún tipo de evento, pero sin bloquear otras tareas en el mismo programa [Referencia 2]. Entonces, la librería "asyncio" de Python con su sintaxis "async/await" nos permite realizar programación asincrónica concurrente.

En resumen, declaras una función 'async' para convertirla en una corutina y, en alguna parte de su cuerpo, usas la palabra clave 'await' para devolver el control de forma cooperativa al bucle de eventos y esperar algún evento externo; como la llegada de datos necesarios para reanudar su tarea o un valor de retorno de otra función.

Escribe mis Iniciales

El ejemplo "write_my_initials.py" preparado para este artículo y explicado a continuación se basa en los ejemplos "offboard_position_ned.py" y "telemetry_takeoff_and_land.py" que se encuentran en la carpeta "MAVSDK-Python/examples". En el ejemplo "write_my_initials.py", haremos que el dron siga de manera autónoma un cierto camino para escribir en el aire las letras que contienen nuestras iniciales. Sólo para ejemplificar, escribiremos las iniciales de Circuit Cellar Magazine (CCM), luego puedes modificar el código para escribir las letras que desees. Veamos qué hice para lograr esta tarea.

Primero, dibujé las iniciales "CCM" en un papel cuadriculado y determiné la cantidad mínima de puntos necesarios para definirlas claramente. La Figura 4 muestra cómo se veía el dibujo. La escala del gráfico es de un metro por división; entonces, cada letra tiene un tamaño de 4 por 5 metros. Todos los puntos definidos están en el plano cartesiano XY; pero al agregar una altitud fija de 5 metros a cada uno de ellos, obtenemos los mismos puntos definidos esta vez en un plano XY que está a 5 metros por encima del nivel del suelo. También podríamos pensar en ellos como si estuvieran definidos en un sistema de coordenadas cartesianas XYZ, donde todos los puntos tienen la misma coordenada Z (ver Figura 5).

Figura 4: Gráfico de cuadrícula con coordenadas de letra definidas

Figura 5: Letras en los sistemas de coordenadas XYZ y NED

Sin embargo, debido a que también usaremos la función "set_position_ned ()" para comandar al dron (como en el ejemplo "offboard_position_ned.py"), debemos darle al dron todos los puntos de navegación en el sistema de coordenadas NED. Por esa razón, cada uno de nuestros puntos definidos en el sistema de coordenadas XYZ debe traducirse al sistema de coordenadas NED. Las etiquetas de eje en la Figura 5 ya muestran cómo se definen los sistemas de coordenadas XYZ y NED y cómo sus ejes se corresponden entre sí. Como puedes ver, la coordenada X corresponde al Este, la coordenada Y corresponde al Norte y la Z corresponde a -Down.

La mayor parte del código de inicialización para este ejemplo es el mismo que el que se encuentra en el ejemplo "offboard_position_ned.py". La función de entrada 'main' del programa también es async def run() (ve el Listado de Código 1) y las primeras líneas de código a cargo de los pasos de inicialización se explican por sí mismas. En la línea de código 10, con drone = System () instanciamos un objeto "System", que en la API MAVSDK representa a la aeronave y nos permitirá interactuar con ella. Con la línea 11 inmediatamente debajo, estamos haciendo una conexión UDP al dron, a una dirección IP predeterminada y al puerto 14540. Con "udp://:14540" esperamos encontrar al dron en la dirección 'localhost: 14540'. Ese será el caso cuando nuestro script Python se ejecute en la misma máquina que la simulación SITL.

Listado de Código 1: Pasos de inicialización

Luego, con un bucle "async for" (línea 14), sondeamos el estado de conexión del dron hasta que se reciba un estado "conectado"; después de lo cual imprimimos el código de identificación del dron (UUID) y rompemos el bucle "async for"; de lo contrario, el ciclo se ejecutaría indefinidamente porque en MAVSDK, los datos de telemetría PX4 se reciben como flujos continuos. La línea 20 arma el dron y la línea 23 nos permite esperar hasta que hayamos adquirido las coordenadas de la posición incial del dron (hablaremos sobre la función get_drone_home_pos(drone) más adelante). La línea 26 establece una pose inicial para el dron antes de cambiar al modo de vuelo "offboard" de PX4 en las líneas 29 a 35. El modo de vuelo "offboard" requiere que comencemos enviando algunas poses previas antes de cambiar a este modo de vuelo. Si por algún motivo el cambio de modo de vuelo falla, el dron se desarma y se ejecuta return desde la función "principal" para abortar todo el programa. El modo de vuelo "offboard" de PX4 nos permite controlar el dron mediante el uso de comandos de puntos de ajuste ("setpoints") de posición, velocidad, aceleración (empuje) y orientación mediante el protocolo MAVLink.

El Listado de Código 2 muestra cómo cada una de las tres letras para las iniciales se definen como listas Python (en realidad, como "lista de listas"); en el que cada punto vértice de una letra es una lista interna de coordenadas NED en metros y un ángulo de orientación en grados. El ángulo de orientación "Yaw" es el ángulo medido en sentido horario desde la línea Norte, y es el ángulo que debe tener el dron después de alcanzar la coordenada NED dada. Por ejemplo, un ángulo de orientación de 270 grados significa que el dron apuntará hacia el Oeste. En la línea 3, tenemos la primera letra "C" definida como una lista que contiene ocho puntos vértice. Las coordenadas NED para cada punto se copiaron de las Figuras 4 y 5; los ángulos de orientación se seleccionaron al azar, por lo que sus valores no tienen mayor importancia en lo que se refiere a este ejemplo en particular. Para la segunda letra 'C', en un bucle 'for', agregamos 6 a la coordenada Este de cada punto contenido en la primera letra 'C', para hacer una copia que esté desplazada 6 unidades hacia la derecha (ver líneas 7-9). La Figura 4 muestra intuitivamente cómo eso tiene sentido. Para la última letra (la letra 'M') definida en las líneas 11-12, también copié las coordenadas del gráfico de cuadrícula y le di a cada punto un ángulo de orientación "Yaw" aleatorio.

Listado de Código 2: Listas de letras y ciclo 'for' de navegación

En la línea 14, las listas de las tres letras se concatenan en una lista única llamada path_points_list utilizando el operador de concatenación '+' de Python. A continuación, en el bucle "for", iteramos sobre cada punto contenido en la lista mencionada anteriormente y hacemos que el dron navegue hacia cada uno de los puntos en el orden dado. Por ejemplo, para ir al punto actual, en las líneas 18-21 primero recuperamos las coordenadas North, East y Down, junto con el ángulo de orientación Yaw, y en las líneas 23-24 calculamos el ángulo del punto en cuestión con respecto al Este y su distancia horizontal desde el origen (la posición inicial del dron) usando la función trigonométrica arcotangente y la fórmula de Pitágoras, como si estuviéramos en el plano cartesiano XY (ver Figura 6). Luego, en las líneas 26-29, convertimos el ángulo del punto (con respecto al eje Este) en ángulo de orientación (con respecto al eje Norte), y con ese ángulo, la distancia, la latitud y longitud de inicio (punto de despegue) del dron, llamamos a la función get_dest_latlong() para calcular las coordenadas GPS del punto objetivo actual.

Figura 6: Cálculo de distancia y ángulo de punto

Debido a que la distancia del dron al punto objetivo actual se medirá en la definición asíncrona check_is_at_goal(drone) (hablaremos sobre esta función más adelante) para verificar si el drone ha alcanzado punto objetivo actual, rellenamos la variable global cur_goal_point_pos (que es un diccionario Python, en realidad) con la latitud, longitud y altitud del objetivo actual. A continuación, en la línea 35 llamamos a la función drone.offboard.set_position_ned() para fijar las coordenadas NED y ángulo Yaw actuales como la siguiente pose deseada para el dron. La palabra clave "await" en esta línea garantiza que el bucle "for" se pausará hasta que el dron reciba esta nueva pose objetivo. Finalmente, en la línea 38 llamamos a la función check_is_at_goal(drone), función que retornará después de que el drone alcance el objetivo actual. La Figura 7 muestra una captura de pantalla del ejemplo "write_my_initials.py" en ejecución.

Figura 7: Ejemplo 'write_my_initials.py' corriendo

Funciones Auxiliares

El Listado de Código 3 muestra las dos funciones auxiliares asincrónicas que forman parte de 'write_my_initials.py'. Expliquemos qué hacen estas funciones. La primera función, async def get_drone_home_pos (drone) se encarga de obtener las coordenadas GPS y la altitud relativa de la posición inicial del dron. Con el bucle 'async for' en las líneas 5-11, esta función comienza a iterar sobre la secuencia de telemetría entrante de la posición 'home' (posición de despegue del dron), y después de recibir la primera lectura y almacenarla en el diccionario drone_home_pos, en la línea 11 retorna a la función que la llamó. La posición de inicio es el lugar en el que despega el dron y no cambiará durante la ejecución de nuestro script Python, por lo que sólo necesitamos leerla una vez al principio. Si recuerdas, llamamos a esta función en los pasos de inicialización en la función "principal" async def run() (ve la línea 23 en el Listado de Código 1).

Listado de Código 3: Funciones asincrónicas auxiliares

La segunda función, async def check_is_at_goal(drone) se encarga de monitorear el progreso del drone hasta el objetivo actual. Para lograr esto, lee iterativamente la posición actual del dron llamando a drone.telemetry.position() en el bucle "async for" (línea 21). Después de obtener la posición actual del dron, la latitud, longitud y altitud relativa se almacenan en el diccionario drone_current_pos (líneas 23-25). En la línea 27, calcula la distancia horizontal en metros entre la posición actual del dron y la posición del objetivo actual mediante la función get_haversine_distance(). La fórmula "Haversine" utilizada en esta función permite calcular "distancias circulares" (arcos) sobre la superficie de la Tierra entre dos conjuntos de coordenadas de latitud y longitud. En la línea 30, también calculamos la distancia vertical; la cual será útil cuando el dron vaya a un punto en una altitud diferente a la anterior. Luego, con la primera sentencia 'if' (línea 33), verificamos si el dron ha reducido la distancia horizontal hacia su objetivo actual en al menos 1 metro e imprimimos el valor de distancia actual (redondeado) a la ventana de la terminal, solo para propósito de visualizar el progreso de navegación horizontal del dron.

Con la segunda sentencia 'if' (línea 37), verificamos si mabas distancias horizontal y vertical hacia la meta actual son menores o iguales a los errores de distancia máxima permitidos MAX_HOR_DIST_ERROR y MAX_VER_DIST_ERROR antes de considerar al objetivo actual como alcanzado. Si esto es así, después de imprimir un mensaje, la función retorna a la función 'principal' que la llamó, en la que el bucle 'for' encargado de controlar la navegación (consulta la línea 16 en el Listado de Código 2) seleccionará el siguiente punto y comandará al dron navegar hacia él.

Ejecutando el Ejemplo con un Dron Real

Este mismo ejemplo se puede ejecutar con un quadricóptero real conectado a la PC a través de módulos de telemetría. Esto, después de cambiar la línea 11 en el Listado de Código 1 por:\

await drone.connect (system_address = "serial:///dev/ttyUSB0:57600")

Donde '/dev/ttyUSB0' es el nombre de puerto asignado por tu sistema Linux al módulo de telemetría USB conectado a tu PC. Obviamente, en este caso ya no necesita ejecutar los simuladores Gazebo o jMAVSim; tampoco podrás usar QGroundControl. Si QGroundControl estuviera corriendo, se conectaría automáticamente al dron abriendo el puerto serie USB del módulo de telemetría y nuestro script Python no podría abrir el mismo puerto para conectarse también al dron. Primero puedes usar QGroundControl para verificar si el dron se conecta correctamente con tu computadora a través de los módulos de telemetría, y luego cerrarlo antes de ejecutar el script Python.

Ten en cuenta que podría estar omitiendo algunos detalles adicionales (fuera del alcance de este artículo) acerca de cómo ejecutar este código MAVSDK-Python para controlar un dron real. El punto que quiero poner en relevancia aquí es que, en general, una vez que tienes una aplicación que se ejecuta correctamente en la simulación, probarla con un dron real no implicará hacer grandes cambios con respecto al código que escribiste y las herramientas de software que has estado utilizando. Sin embargo, no recomiendo ejecutar este ejemplo con un dron real, a menos que tengas al menos una experiencia relativamente buena configurando y volando quadricópteros reales y entiendas bien cómo funcionan los modos de vuelo PX4. Sin embargo, si deseas ejecutarlo con un dron real, te recomiendo probar primero con un ejemplo más simple como "takeoff_and_land.py" para asegurarte que tu sistema (PC/telemetría/dron) funciona bien. Recuarda también prever todo el espacio requerido que necesitaría el dron para cubrir toda la ruta de vuelo.

Conclusiones

Hasta este punto espero que hayas visto lo relativamente fácil que es einiciarse en el desarrollo de aplicaciones de vuelo autónomo para drones con MAVSDK-Python. Efectivamente, debes conocer Python de antemano y también tener la cadena de herramientas instalada y funcionando correctamente. Y debido a que MAVSDK-Python usa la librería "asyncio", también debes estar familiarizado con la programación asincrónica; nada sofisticado, solo una comprensión general acerca de cómo funciona la concurrencia y específicamente cómo usar las palabras clave "async/await".

Si deseas seguir experimentando con la API MAVSDK-Python, te recomiendo hacer hacer un par de cosas. Primero, obten acceso al espacio de trabajo "Slack" de PX4 y a su foro "Discuss" donde podrás obtener soporte para todo lo relacionado con el ecosistema PX4, no solo MAVSDK (consulta la sección de Recursos). Segundo, prueba y estudia todos los ejemplos incluidos en el repositorio MAVSDK-Python. Algunos de ellos son muy intuitivos y fáciles de entender; otros requerirían que investigues un poco más. Lee también la documentación de la API de MAVSDK para obtener una referencia detallada sobre las funciones de la API y las estructuras de datos utilizadas en los ejemplos.

En artículos posteriores a éste, presentaré algunos ejemplos más avanzados de vuelo autónomo con MAVSDK, y también hablaré acerca de cómo actualizar un quadricóptero incluyéndole una computadora acompañante ("companion computer") para aplicaciones de seguimiento autónomo de objetos con visión por computador. También hablaré sobre cómo integrar PX4 con Robot Operating System (ROS) mediante MAVROS (el puente MAVLink a ROS). ¡Hasta la próxima!

-------------------------

REFERENCIAS
[Reference 1] https://www.mathworks.com/help/aeroblks/about-aerospace-coordinate-systems.html
[Reference 2] https://snarky.ca/how-the-heck-does-async-await-work-in-python-3-5/

RECURSOS
MAVSDK
https://mavsdk.mavlink.io/develop/en/index.html

PX4 SITL simulation
https://dev.px4.io/v1.9.0/en/simulation/index.html

Development Environment Installation
https://dev.px4.io/v1.9.0/en/setup/dev_env.html

Getting started with MAVSDK-Python
https://auterion.com/getting-started-with-mavsdk-python/

MAVSDK-Python: easy asyncio
https://auterion.com/mavsdk-python-easy-asyncio/

PX4 platform
https://px4.io/

QGroundControl
http://qgroundcontrol.com/
PX4 Support (Slack and Discuss)
https://dev.px4.io/v1.9.0/en/contribute/support.html

Local Tangent Plane Coordinates (NED Coordinate System)
https://en.wikipedia.org/wiki/Local_tangent_plane_coordinates

Speed Up Your Python Program With Concurrency
https://realpython.com/python-concurrency/

Install Ubuntu 18.04 LTS in a VirtualBox
https://linuxhint.com/install_ubuntu_18-04_virtualbox/