Introdução ao AirSim

O AirSim, acrônimo para “Aerial Informatics and Robotics Platform” [1], é um simulador de veículos aéreos não tripulados (i. e. UAVs), como quad-rotors, e outros tipos de veículos que foi construído como um plugin de código aberto e multiplataforma da Microsoft para a Unreal Engine [2], um dos mais populares e realistas motores para construção de jogos e renderização disponíveis no mercado. O objetivo da plataforma é melhorar as pesquisas de inteligência artificial, por meio de deep learning, visão computacional e algoritmos de reforço de aprendizagem para veículos autônomos.

Dessa forma, o AirSim conta com algumas características principais que auxiliam nos pontos acima, por exemplo [1]:

• Simulações chamadas “hardware-in-loop” (HIL), onde é possível usar controladores de voo reais, como o Pixhawk [3], o que habilita alto grau de realismo na simulação;
  
• Simulações “software-in-loop” (SITL), onde o controlador de voo é apenas simulado, o que permite o uso do AirSim mesmo sem equipamentos como Pixhawk;
  
• Por ser um plugin da Unreal Engine, é possível rodar simulações em qualquer tipo de ambiente que essa engine seja capaz de criar. Dessa forma, as possibilidades são praticamente ilimitadas, dado os recursos de renderização foto-realística e física da engine;
  
• Disponibilidade de APIs para obter dados dos veículos, como dados de sensores e imagens, assim como APIs para controlá-los independentemente da plataforma (Pixhawk, DJI Matrice, etc). Esse tipo de recurso permite que os códigos desenvolvidos e testados no simulador possam ser disponibilizados em diferentes plataformas sem ser necessário conhecer detalhes internos delas;
  
• Ferramentas de registro de dados para analises do comportamento e obtenção de dados de sensores em momentos específicos da simulação.
  

Por fim, os autores detalham em [4] a arquitetura (Figura 1) e os detalhes internos do funcionamento do AirSim, explicando aspectos que variam desde a física que controla a propulsão de veículos quad-rotors até mesmo às convenções adotadas para leituras simuladas de alguns sensores, como magnetômetros e barômetro.

Figura 1: Arquitetura do AirSim e a interação entre componentes do simulador e físicos [4]

A seção a seguir irá descrever um passo-a-passo para a realização da instalação do Microsoft AirSim em ambiente Windows. A instalação para Linux, apesar de estar prevista, ainda não foi liberada.

Guia de Instalação do AirSim

1. Instalação do Microsoft Visual Studio 2015 (VS2015)
   

   • Realizar o download do VS2015 Update 3. A versão Community, gratuita para fins não comerciais, já é suficiente. Futuramente, quando o AirSim estiver completamente disponível para ambientes Linux ou macOS, a versão a ser usada deve ser a Visual Studio Code 2015;
     
   • Realizar a instalação completa do VS2015, seguindo os passos normais. Caso não se deseje realizar a instalação completa, o ponto de atenção é garantir que os compiladores de C++ (VC++) estão selecionados, pois são usados para compilar o AirSim. Além disso, ferramentas adicionais, como o Git for Windows auxiliam no download dos pacotes. Dessa forma, recomenda-se a instalação completa, conforme abaixo:
     
     

     Figura 2: Opções para realizar a instalação completa do VS2015 (Community)

     
     

2. Instalação da Unreal Engine
   

   • Realizar o download da Unreal Engine 4 do site. É necessário realizar um rápido registro antes de fazer o download;
     
   • Após o download, fazer a instalação padrão da Unreal Engine, onde nenhuma opção específica precisa ser selecionada;
     
   • Executar a Unreal Engine, usando a opção “Epic Games Launcher” no Menu Iniciar do sistema operacional. Na primeira vez, é necessário logar com a conta criada antes do download. Para inicializar a engine, basta clicar em “Inicializar”.
     
   

   Figura 3: Tela inicial do Epic Games Launcher, que dá acesso à Unreal Engine

    

   • Até o momento da escrita desse guia, a versão mais recente disponível da Unreal Engine é a 4.15. Porém, os autores do AirSim explicitamente avisam que a versão suportada é a 4.14. Particularmente, foi possível executar os testes tanto na versão 4.14 quanto 4.15.
     
   • Para instalar a versão recomendada (4.14), clique em “Biblioteca”, em seguida em “Adicionar Versões”. Selecione a versão 4.14.3 e, por fim, clique em “Instalar”.
   

   Figura 4: Instalação da versão recomendada (4.14) da engine para o plugin AirSim

   
   

   • Selecione o local de instalação desejado e aguarde o download (~3,1 GB) e instalação. Após instalação, para executar a nova versão da engine, basta mudar a versão para a 4.14.3 no botão Inicializar (ou Launch, na versão em Inglês).
     
   

   Figura 5: Seleção da versão recomendada (4.14) para execução da engine

   
   

3. Instalação das dependências
   

   • O AirSim possui duas dependências externas de bibliotecas de C++, que são a Eigen [5], focada em álgebra linear, e a Boost
     [6],com foco em produtividade na codificação. Os passos descritos na documentação do AirSim são suficientes para realizar a instalação de tais bibliotecas. Portanto:
     
     1. Para instalar a Eigen, siga os passos desse link. Os passos detalham a opção de instalar tanto em ambiente Windows quanto em Linux, apesar disso, a instalação foi tentada apenas em ambiente Windows;
        
     2. Para instalar a Boost, siga os passos desse link. De forma similar ao tópico acima, apesar da opção para ambas plataformas, foi realizada a instalação apenas em no Windows;
        
   • O AirSim também precisa do CMake
     [7] para compilar a rpclib. Basta baixar a versão compatível com o sistema operacional nesse link e fazer a instalação padrão, com o único ponto de atenção de adicionar o Cmake às variáveis de ambiente para todos os usuários:
     
   

   Figura 6: Opção para que o CMake seja adicionado às variáveis de ambiente para todos usuários.

   
   

4. Instalação do QGroundControl (controlador de voo)
   

   • O QGroundControl [8] é necessário para configurar o controlador de voo. Ela é necessária quando se usa a simulação HIL, com um PixHawk físico, que precisa ser configurado, ou na simulação SIL, quando se usa roda o firmware do controlador e usa-se um controle genérico (Xbox, por exemplo) para controlar o drone.
     
   • O pacote para download e as instruções de instalação para Linux ou Windows estão disponíveis nesse link.
     

5. Instalação do AirSim e compilação do código para geração dos executáveis
   

   • Inicie o VS2015 x64 Native Tools Command Prompt e navegue para o diretório onde deseja-se instalar o AirSim.
     
   • Já no diretório desejado, use o comando abaixo para baixar o repositório completo e atualizado do AirSim:
     

     git clone https://github.com/Microsoft/AirSim.git

Figura 7: Clonagem do repositório do AirSim via git

• Após o download do repositório, realizar os comandos abaixo para que o AirSim seja compilado e gere os binários necessários do plugin. São esses binários, localizados na estrutura Unreal/Plugins que devem ser copiados para os projetos criados na Unreal Engine. Até o momento da escrita desse guia, não havia ainda versão para compilar a versão para Linux do AirSim.

  cd AirSim
  build.cmd

• Caso a compilação ocorra com sucesso, será apresentado o resultado abaixo:
  

Figura 8: Compilação com sucesso do AirSim

• Dessa forma, o plugin AirSim terá sido compilado e disponível no diretório Unreal\Plugins, que deverá ser copiado para os projetos do Unreal onde desejar-se usá-los:
  
  

  Figura 9: Diretório com os binários compilados do plugin AirSim

  6. Criação de projeto na Unreal Engine e inclusão do plugin AirSim no mesmo
  

  • Essa parte está melhor detalhada no vídeo dos autores do AirSim disponível no YouTube. De qualquer forma, os passos também foram detalhados a seguir.
    
  • É possível começar um projeto totalmente vazio e criar-se na engine o ambiente que se deseja simular. Caso se deseje iniciar com algum conteúdo inicial, deve-se adquirir um ambiente na loja da Unreal ou baixar algum ambiente grátis da loja ou mesmo da seção “Aprendizagem” da Unreal.
    
  • Como sugestão para esse guia, será adotado um ambiente grátis, da série Infinity Blade. Para baixa-lo, abra a Unreal Engine, vá para “Loja”, pesquise por “Infinity” e mande adicionar ao Carrinho uma das opções, como a Infinity Blade: Fire Lands. Após isso, basta acessar o carrinho de compras e clicar na opção “Checkout” para que o ambiente seja baixado e fique disponível na Biblioteca.
    
  

  Figura 10: Instalação de um ambiente para rodar a simulação

  
  

  • É necessário criar um novo projeto antes de adicionar o ambiente ao mesmo. Para isso, inicialize a Unreal Engine na versão 4.14.3, clicando no botão “Inicializar”. Selecione a opção “Novo Projeto” e selecione a aba C++. É possível iniciar o projeto com algum conteúdo inicial, mas os autores do AirSim recomendam o uso do Código Básico, sem conteúdo inicial, conforme opções abaixo. Altere o nome desejado e clique em “Criar Projeto” para que o mesmo seja criado.
    
  

  Figura 11: Criação de um novo projeto vazio na Unreal Engine

  
  

  • Agora com o projeto criado, basta adicionar o ambiente desejado ao mesmo. Para isso, vá à Biblioteca, selecione o ambiente previamente baixado, clique em Adicionar a Projeto e selecione o projeto recém-criado, clicando em “Adicionar” para confirmar.
    
  

  Figura 12: Adição de um ambiente baixado a um projeto da Unreal Engine

  
  

  • Com o ambiente baixado e o projeto criado, é necessário adicionar o AirSim projeto, lembrando que o AirSim é um plugin criado para a Unreal Engine. Para tanto, localize a pasta onde o AirSim (\Unreal\Plugins) foi compilado (Figura 9) e a copie para a raiz do novo projeto. A estrutura deve ficar semelhante à da figura a seguir:
    
  

  Figura 13: Estrutura de arquivos após copiar o plugin AirSim para o projeto do Unreal

  
  

  • Para que o projeto formalmente reconheça o AirSim, é necessário adicioná-lo como uma dependência no arquivo de configuração “<nome do projeto>.uproject”. Use algum editor de texto para abrir o arquivo e adicione a dependência para que o arquivo fique da seguinte forma:
  

  Figura 14: Edição do arquivo “.uproject” para inclusão da dependência do plugin AirSim

  
  

  

  Figura 15: Geração dos arquivos atualizados do Visual Studio para o projeto

   

• Por fim, para que o projeto fique pronto para execução, basta clicar com o botão direito no arquivo <Nome do projeto>.uproject e gerar os arquivos do Visual Studio, usando a opção “Generate Visual Studio Project Files”.
• Com isso, esse projeto está pronto para ser executado com o AirSim. Mais detalhes de como inicializar estão na seção “Execução do Simulador”.
  
   

  7. Instalação dos requisitos para executar o modo “Software-in-loop”
  

  • Esse passo é opcional e aplicável apenas quando não se dispõe de um controlador de vôo, como o Pixhawk ou Pixhawk mini. Como é o caso do autor desse guia, os passos abaixo foram realizados com base na documentação descrita nesse link.
    
  • Há duas opções principais para rodar o firmware que simula o controlador de voo: instalação do bash no Windows (Opção 1) ou instalação em uma máquina Linux física ou virtual (Opção 2). A Opção 1, que foi adotada pelo autor, requer a instalação do bash, cujo procedimento está detalhado abaixo:
    
    • O bash funciona por meio da execução de um subsistema em Linux diretamente no Windows. Para instalação do bash, basta seguir as instruções nesse link, que estão suficientemente detalhadas. Como ponto de atenção, é necessário que o Windows executado seja de 64 bits e pelo menos na versão “Windows 10 Anniversary Update build 14393“.
      
  • A partir desse ponto, os passos independem se a instalação está ocorrendo no bash ou numa máquina Linux;
    
  • Usando o Bash no Windows ou um terminal no Ubuntu, realize a atualização dos pacotes e bibliotecas de dependência, usando os comandos abaixo (mais detalhes nesse link):

    sudo add-apt-repository ppa:george-edison55/cmake-3.x -y
    sudo apt-get update
    sudo apt-get install python-argparse git-core wget zip \
    python-empy qtcreator cmake build-essential genromfs -y
    	# simulation tools
    sudo apt-get install ant protobuf-compiler libeigen3-dev libopencv-dev openjdk-8-jdk openjdk-8-jre clang-3.5 lldb-3.5 -y
    

     

    – Em seguida, siga as instruções referentes à instalação do pacote do hardware NuttX. Como o controlador roda em um hardware ARM Cortex M4, os passos abaixo são necessários para que seja possível compilar o firmware do PX4.
    

    • Com as dependências acima concluídas, baixe o código-fonte do PX4 e compile o mesmo na versão SITL. Para tanto, basta seguir os comandos abaixo, que podem ser executados no Bash, num terminal do VS2015 ou num terminal do Linux:
      

      git clone https://github.com/PX4/Firmware.git
      cd Firmware
      git submodule update --init --recursive
      make posix_sitl_default
      

       

    • • Remover itens desnecessários ou instalações anteriores do GCC, usando os comandos a seguir:
        

        sudo apt-get remove gcc-arm-none-eabi gdb-arm-none-eabi binutils-arm-none-eabi gcc-arm-embedded
        sudo add-apt-repository --remove ppa:team-gcc-arm-embedded/ppa
        

         

      • Remover o gestor de modens seriais do Ubuntu, que pode interferir no uso da porta serial ou USB. É um passo opcional, recomendado quando se utiliza uma máquina Linux. No caso do Bash, esse passo pode ser ignorado.

        sudo apt-get remove modemmanager

         

      • Atualizar a lista de dependências e instalá-las usando o script abaixo:

        sudo apt-get install python-serial openocd \
            flex bison libncurses5-dev autoconf texinfo build-essential \
            libftdi-dev libtool zlib1g-dev \
            python-empy  -y
        

         

      • Por fim, instale o GCC 5.4 manualmente, usando o script abaixo:
        

        pushd .
        cd ~
        wget https://launchpad.net/gcc-arm-embedded/5.0/5-2016-q2-update/+download/gcc-arm-none-eabi-5_4-2016q2-20160622-linux.tar.bz2
        tar -jxf gcc-arm-none-eabi-5_4-2016q2-20160622-linux.tar.bz2
        exportline="export PATH=$HOME/gcc-arm-none-eabi-5_4-2016q2/bin:\$PATH"
        if grep -Fxq "$exportline" ~/.profile; then echo nothing to do ; else echo $exportline >> ~/.profile; fi
        . ~/.profile
        popd
        

    • Para inicializar o firmware no modo SITL, basta executar o comando abaixo:
      

      ./build_posix_sitl_default/src/firmware/posix/px4 ./posix-configs/SITL/init/lpe/iris

       

• Caso o firwmare tenha sido inicializado com sucesso, serão apresentados alguns comandos abaixo:
  

Figura 16: Execução do firmware do PX4, que se comunica pela porta 14560 (UDP)

• 8. Execução do simulador
  

  • O simulador pode ser executado de duas formas: HIL e SITL. A primeira delas não foi testada pelo autor desse guia, por não dispor do hardware necessário. De qualquer forma, todos os pré-requisitos necessários e passos detalhados para executar o simulador nesse modo estão detalhados nesse vídeo.
    
  • O modo SITL parte do princípio que os passos opcionais do firmware, detalhados na seção anterior foram realizados e que o comando para inicialização do firmware no modo SITL foi executado, ou seja, o firmware está rodando e aguardando dados do controle e do drone na porta UDP 14560 (Figura 16). Também é necessário que exista um controle (Xbox 360 ou One, por exemplo), conectado à porta USB. A calibração do mesmo só será feita após a inicialização do simulador. Por fim, no arquivo de configuração do AirSim, a opção “UseSerial” deve estar colocada como “false”.
    
  • Navegue até o projeto desejado e clique duas vezes no arquivo de solução do Visual Studio (.sln). Por exemplo, a figura abaixo mostra um dos projetos criados e já configurados para uso com o AirSim, vide passos anteriores:
    
  

  Figura 17: Arquivo de solução do VS2015 para iniciar a simulação

  
  

  • Com o editor do Visual Studio 2015 aberto, clique em pressione F5 ou clique em “Local Windows Debugger” para rodar o projeto. Será iniciada a compilação e, em seguida, será aberto o ambiente da Unreal Engine:
    
  

  Figura 18: Ambiente do Visual Studio após início do projeto

  
  

  

  Figura 19: ambiente da Unreal Engine aberto e pronto para executar a simulação

  
  

  • Vá para a opção “Settings”, “World Settings” e no item “Substituição Game Mode” selecione a opção “SimGameMode”, conforme abaixo:
    
  

  Figura 20: Opção “SimGameMode” para que o projeto seja executado como do AirSim

  
  

  • Com isso, iniciar o projeto, clicando em “Reproduzir”. Dessa forma, será inicializada a simulação.
    
  

  Figura 21: Simulação iniciada no ambiente simulado

  
  

  • Caso esteja executando o modo HIL, basta usar o controle físico para fazer com que o drone voe. Porém, se estiver executando no modo SITL, como foi o caso do autor na preparação desse guia, com a simulação em andamento, inicie o programa QGroundControl.
    
  • Para que seja possível controlar o drone com um controle genérico, clique no botão roxo “Q” à esquerda, para acessar as preferências. Na aba “General”, marque a opção “Virtual Joystick”.
    
  

  Figura 22: Habilitar o QGroundControl para usar joystick virtual

  
  

  • Já na aba CommLink, clique em “Add” e crie uma conexão do tipo UDP na porta 14550, conforme figura abaixo. Importante: caso esteja-se executando o firmware do Px4 em uma máquina Linux física em rede ou virtual, será necessário colocar o IP da mesma, e não manter o endereço de localhost. No caso abaixo, como o firmware está rodando no bash, foi mantido o endereço 127.0.0.1. Além disso, foi usada a porta 14550 padrão porque a mesma foi mantida no arquivo de configuração do AirSim. Caso a mesma tenha sido alterada, é necessário atualizar. Acesse esse link para ver detalhes de todas configurações possíveis.
    
  

  Figura 23: Criação do link de comunicação do QGroundControl com o veículo no simulador

  
  

  • Com o link de comunicação criado, clique em “Connect” para inicializar a comunicação. Caso a comunicação tenha sucesso, na aba “Fly” do QGroundControl será possível visualizar uma conexão com o “Vehicle 1”. Da mesma forma, na tela do firmware do Px4 será possível visualizar dados de voo sendo recebidos:
    
  

  Figura 24: Conexão bem sucedida e conectado ao veículo no simulador

  
  

  

  Figura 25: Firmware do Px4 com dados atualizados recebidos da simulação

  
  

  • Antes de iniciar o voo, é necessário calibrar o controle sendo usado. Para isso, acessar a opção “Preferences” e em seguida “Joystick”. Por fim, clicando em “Calibrate” e seguir as instruções na tela. Mesmo realizando essa calibração, é praticamente impossível controlar de forma precisa o drone sem um controle de rádio frequência. Logo, o modo SITL deve ser usado apenas como um paliativo.
    
  

  Figura 26: Opções para calibração do controle

  
  

  • Com o controle calibrado, volte para a opção “Fly“. Agora já é possível solicitar que o drone seja ativado, clicando na opção “Arm” e em seguida decole, acionando a opção “Takeoff“. Após os comandos realizados aqui, deve-se voltar ao simulador na Unreal Engine para controlar o voo.
    
  

  Figura 27: Opções para ativar e decolar o drone

  
  

  • Com o drone ativado e feita a decolagem, é agora possível voar com mesmo pelo ambiente simulado na Unreal Enginem:
    
  

  Figura 28: Simulação em andamento, sendo controlada no modo SITL

  
  

  • No ambiente do simulador, pressione F1 para obter uma lista completa de comandos e opções, como troca de câmera, ativação de visão do LiDAR, etc. Os comandos disponíveis estão na figura a seguir:
    
  

  Figura 29: Lista de comandos e forma de modificar a visualização pelo AirSim

  
  

  9. Obtendo dados da simulação com o LogViewer
  

  • Por fim, é ainda possível usar o “LogViewer” para obter dados da simulação, como por exemplo coordenadas do GPS e leituras de outros sensores. Para isso, navegue até a pasta do AirSim, vá em “LogViewer” e inicie a solução com um duplo-clique em “LogViewer.sln”, mandando executar em seguida (F5).
    
    

    Figura 30: Execução do LogViewer para obtenção de dados do simulador

    
    

  • Com o LogViewer em execução, clique na opção “Connection” à direita, selecione a aba “Socket” e por fim selecione “localhost”, considerando que o simulador e o LogViewer estão sendo executados na mesma máquina. Em seguida, clique em “Connect”.
    
    

    Figura 31: Conexão do LogViewer com o simulador

  • Caso o simulador esteja em execução, será possível obter leituras de sensores diretamente da simulação. Para isso, basta selecionar os itens desejados dentre as opções à esquerda e adicioná-los à área de trabalho, que passará a mostrar as leituras em tempo real. Para mais detalhes de como usar o LogViewer, acessar este link.
    
  

  Figura 32: Leitura de medidas em tempo real diretamente da simulação pelo LogViewer

  
  

Referências

[1]    Microsoft, “Microsoft AirSim,” 2017. [Online]. Available: https://github.com/Microsoft/AirSim. [Accessed: 03-Apr-2017].

[2]    Epic Games, “What is Unreal Engine 4,” 2017. [Online]. Available: https://www.unrealengine.com/what-is-unreal-engine-4. [Accessed: 04-Mar-2017].

[3]    M. Meier, Lorenz; Honegger, Dominik; Pollefeys, “Home – Pixhawk Flight Controller Hardware Project.” [Online]. Available: https://pixhawk.org/. [Accessed: 04-Mar-2017].

[4]    S. Shah, D. Dey, C. Lovett, and A. Kapoor, “Aerial Informatics and Robotics Platform,” 2017.

[5]    B. Jacob and G. Guennebaud, “Eigen,” 2017. [Online]. Available: http://eigen.tuxfamily.org/index.php?title=Main_Page#Overview. [Accessed: 04-Mar-2017].

[6]    Beman Dawes, David Abrahams, and Rene Rivera, “Boost C++ Libraries,” 2017. [Online]. Available: http://www.boost.org/. [Accessed: 04-Mar-2017].

[7]    “Overview | CMake.” [Online]. Available: https://cmake.org/overview/. [Accessed: 04-Mar-2017].

[8]    “Overview – QGroundControl,” 2017. [Online]. Available: https://donlakeflyer.gitbooks.io/qgroundcontrol-user-guide/content/. [Accessed: 04-Mar-2017].