Introdução

No post anterior (Voos autônomos com o AR.Drone (Parte 1): Node.js + node-ar-drone + ardrone_autonomy), descrevemos um framework que permite a elaboração e execução de missões autônomas com o AR.Drone usando JavaScript. Hoje, apresentamos outro conjunto de ferramentas que, integradas, compõe outro ambiente para o desenvolvimento de aplicações usando o AR.Drone para a realização de voos autônomos.

ROS

O ROS (Robot Operating System) é um framework flexível para escrever softwares para robôs. É uma coleção de ferramentas, bibliotecas e convenções que buscam simplificar a tarefa de dar a plataformas a capacidade de comportamentos complexos e robustos. Além de bibliotecas, provê abstração do hardware, drivers de dispositivos, visualizadores, gerenciamento de pacotes, entre outras facilidades. É compatível com uma variedade de plataformas robóticas e foi desenvolvido com o propósito de encorajar o desenvolvimento colaborativo de softwares para Robótica. A documentação completa encontra-se disponível em Documentation.

Como instalar o ROS

O ROS encontra-se sob a licença BSD open source e possui mais de uma distribuição para diferentes plataformas. Aqui encontra-se um bom passo-a-passo para a instalação do ROS Hydro no Ubuntu 12.04 (Precise). A versão Hydro Medusa é a mais recente. Para instalar outras versões, dê uma olhada em ROS Hydro installation instructions. Também é possível instalar a partir do código fonte, como descrito em Installing on Ubuntu from source.

O driver ardrone_autonomy

O driver ardrone_autonomy é um driver ROS (desmembramento do projeto brown-ros-pkg) para o quadricóptero Parrot AR.Drone. Foi desenvolvido a partir do AR Drone SDK 2.0, que é o kit de desenvolvimento de software oficial para os modelos 1.0 e 2.0 do AR.Drone. Se quisermos controlar o drone e ler dados de seus sensores usando o ROS, precisamos instalar o pacote correspondente a este driver. A estalação será descrita mais à frente, quando falarmos sobre o tum_ardrone.

Para executar o driver, digitamos na linha de comando:

[sourcecode language=”powershell” wraplines=”false”]
fercic@ubuntu:~$ rosrun ardrone_autonomy ardrone_driver
[/sourcecode]

O pacote tum_ardrone

O pacote tum_ardrone implementa voos autônomos para o Parrot AR.Drone, utilizando técnicas de navegação por visão baseadas no PTAM (Parallel Tracking and Mapping). O projeto habilita o AR.Drone para navegar autonomamente em ambientes previamente desconhecidos ou não possuem acesso sinais de um GPS. O pacote implementa os papers Camera-Based Navigation of a Low-Cost Quadrocopter (J. Engel, J. Sturm, D. Cremers) e Accurate Figure Flying with a Quadrocopter Using Onboard Visual and Inertial Sensing (J. Engel, J. Sturm, D. Cremers).

Como instalar o ardrone_autonomy e o tum_ardrone

A maneira mais simples de instalar esses pacotes é através das seguintes linhas de comando:

[sourcecode language=”powershell” wraplines=”false”]
fercic@ubuntu:~$ roscd

fercic@ubuntu:~$ git clone git://github.com/tum-vision/ardrone_autonomy.git ardrone_autonomy

fercic@ubuntu:~$ export ROS_PACKAGE_PATH=$ROS_PACKAGE_PATH:`pwd`/ardrone_autonomy

fercic@ubuntu:~$ cd ardrone_autonomy

fercic@ubuntu:~$ ./build_sdk.sh

fercic@ubuntu:~$ rosmake
[/sourcecode]

Primeiro, vamos para o diretório padrão da instalação do ROS. Em seguida, “clonamos” os arquivos do código-fonte do ardrone_autonomy. Devemos garantir que o diretório do pacote vai ser localizado pelo ROS, por isso o exportamos para o PATH padrão de pacotes do ROS. Por fim, basta movermos para o diretório do pacote e executarmos o arquivo o script de configuração. Então podemos chamar ‘rosmake’ para a construção dos binários.

Se chegamos a este ponto sem problemas, temos o driver ardrone_autonomy instalado e podemos instalar o pacote tum_ardrone:

[sourcecode language=”powershell” wraplines=”false”]
fercic@ubuntu:~$ roscd

fercic@ubuntu:~$ git clone git://github.com/tum-vision/tum_ardrone.git tum_ardrone

fercic@ubuntu:~$ export ROS_PACKAGE_PATH=$ROS_PACKAGE_PATH:`pwd`/tum_ardrone

fercic@ubuntu:~$ rosmake tum_ardrone
[/sourcecode]

O sistema é composto por três elementos:

  • um sistema monocular baseado em SLAM: drone_stateestimation, que inclui PTAM e Visualização;
  • um controlador: drone_autopilot, que precisa das estimativas de estado geradas pelo binário drone_stateestimation;
  • uma GUI: drone_gui, para controlaro drone (por meio de um Joystick ou de um teclado) e para controlar drone_autopilot e drone_stateestimation.

Se a instalação ocorreu sem problemas, os binários estarão disponíveis
ex.:

[sourcecode language=”powershell” wraplines=”false”]
fercic@ubuntu:~$ /opt/ros/hydro/tum_ardrone/bin$ ls

fercic@ubuntu:~$ drone_autopilot drone_gui drone_stateestimation
[/sourcecode]

Para usarmos a ferramenta, precisamos executar os seguintes binários, cada um num terminal, respeitando essa sequencia:

[sourcecode language=”powershell” wraplines=”false”]
# run driver
fercic@ubuntu:~$ rosrun ardrone_autonomy ardrone_driver

# run stateestimation node
fercic@ubuntu:~$ rosrun tum_ardrone drone_stateestimation

# run autopilot node
fercic@ubuntu:~$ rosrun tum_ardrone drone_autopilot

# run gui node
fercic@ubuntu:~$ rosrun tum_ardrone drone_gui
[/sourcecode]

tum_ardrone/drone_stateestimation

É o nó que implementa um Filtro de Kalman Extendido ou Extended Kalman Filter, para a estimação do estado, incluindo o modelo dinâmico do drone; compensação de tempo de atraso; estimação de escala; o mapeamento PTAM. Estima a posição do drone baseado nos dados de navegação e no PTAM. Para rodá-lo, o driver ardrone_autonomy deve estar sendo executado:

[sourcecode language=”powershell” wraplines=”false”]
fercic@ubuntu:~$ rosrun ardrone_autonomy ardrone_driver
[/sourcecode]

Ao rodar este nó,

[sourcecode language=”powershell” wraplines=”false”]
fercic@ubuntu:~$ rosrun tum_ardrone drone_stateestimation
[/sourcecode]

duas janelas são exibidas. A primeira contém as imagens da câmera frontal do AR.Drone, com pontos relacionados ao mapa obtido do PTAM. A segunda janela contém um mapa 3D de localização do drone. Para maiores detalhes sobre as funcionalidades desse nó do pacote, acesse sua documentação.

tum_ardrone/drone_autopilot

É o nó que implementa um controlador PID para o AR.Drone, o procedimento de inicialização automática e a linguagem de script para controlar o sistema de navegação automático. Requer que o drone_stateestimation esteja rodando.

A linguagem de script

O comportamento do piloto automático é setado pelo envio de comandos para /tum_ardrone/com, da forma “c COMMAND”. Uma fila de comandos é mantida, e à medida em que um comando é finalizado (por exemplo, um way point é alcançado), o próximo comando é retirado da fila. A fila pode se limpa pelo envio do comando “c clearCommands”. Os comandos podem ser enviados usando o nó drone_gui. Alguns exemplos de scripts podem ser encontrados em “flightPlans/.txt”.

A seguir, uma breve descrição de cada comando que pode ser incluídos num sript:

Principais comandos:

autoInit [int moveTimeMS] [int waitTimeMS] [int riseTimeMs] [float initSpeed]

Toma o controle, inicia o drone, inicia o PTAM. Isto é:

– inicia o drone e espera até que ele decole; o drone subirá até a altura aproximada de 1 metro.

– inicia o PTAM e toma o primeiro Filtro de Kalman, decola e voa para cima (enviando a velocidade de início como comando de controle) por moveTimeMS, esperando waitTimeMS e então toma o segundo Filtro de Kalman. Esse processo continua até que haja sucesso.

– bons valores padrão são “autoInit 500 800 4000 0.5”

autoTakeover [int moveTimeMS] [int waitTimeMS] [int riseTimeMs] [float initSpeed]

Toma o controlel, inicia o PTAM. Idêntico a autoInit, mas deve ser usado quando o drone já está voando.

takeoff

– toma o controle e inicia o drone.

– não reseta o mapa, nem inicializa o PTAM

setReference [doube x] [double y] [double z] [double yaw]

seta um ponto de referência (usado em goto X X X X)

setMaxControl [double cap = 1.0]

o controle máximo enviado é limitado a [cap], fazendo com que o drone voe mais lentamente.

setInitialReachDist [double dist = 0.2]

diz a que distância mínima o drone deve estar de um way point inicialmente

setStayWithinDist [double dist = 0.5]

drone tem que ficar próximo a um way point por uma certa quantidade de tempo.

setStayTime [double seconds = 2.0]

tempo que o drone tem que ficar dentro de [stayWithinDist] para um alvo ser considerado alcançado.

clearCommands

limpa todos os alvos, de tal maneira que o próximo comando seja executado imediatamente.

goto [doube x] [double y] [double z] [double yaw]

voa para posição (x,y,z,yaw), relativa ao ponto de referência atual.

bloqueia até que o alvo seja alcançado de acordo com o conjunto de parâmetros

moveBy [doube x] [double y] [double z] [double yaw]

move para (x,y,z,yaw), relativa à posição do alvo atual

bloqueia até que o alvo seja alcançado, de acordo coms parâmetros

moveByRel [doube x] [double y] [double z] [double yaw]

move por (x,y,z,yaw), relativa à atual posição estimada do drone

bloqueia até que o alvo seja alcançado, conforme os parâmetros

land

inicia a aterrissagem (usa a aterrissagem automática do drone)

lockScaleFP

define um ponto que não muda quando a escala é re-estimada para a atual posição do drone; scaleFP só pode ser definida quando PTAM está bom, ou seja, isto é, seu resultado é adiado até que PTAM seja inicializado e esteja bom; é necessário fixar useWorldFixpoint em dynammic_reconfigure.

Parâmetros dinamicamente configuráveis

Leia mais sobre o pacote dynamic_reconfigure para mais detalhes sobre parâmetros dinamicamente configuráveis.

  • Ki_X, Kd_X, Kp_X: são os parâmetros do controlador PID para roll/pitch, gaz (up/down) e yaw.
  • max_X: máximo respectivo valor do comando de controle enviado.
  • rise_fac: os comandos de subida são maiores do que seus respectivos comando de queda por este fator. Isto é devido ao drone algumas vezes cair de forma imprevisivelmente rápida para grandes comandos de queda, porém algumas vezes subir requer grandes comandos de subida.
  •  aggressiveness: multiplicado pelo componente PI de todos os comandos enviados; baixos valores levam o drone a voar mais lentamente.

tum_ardrone/drone_gui

O nó drone_gui oferece uma interface simples (QT GUI) para controlar o nó drone_autopilot, o nó drone_stateestimation e para pilotar o drone manualmente por um teclado ou joystick. A seguir descrevemos suas principais funcionalidades.

Na seção Node Communications Status (1), vemos: Drone Navdata – a frequência de atualização do monitoramento de /ardrone/navdata, que deve estar entre 150 e 200Hz se o AR.Drone estiver conectado e o driver ardrone_autonomy estiver rodando; Drone Control – a frequência com que os comandos de controle são visualizados e enviados ao drone (/cmd_vel); Poses Estimates – a frequência com que é feita a previsão do estado pelo nó drone_stateestimation (por padrão é de 30Hz); Joy Input – monitora /joy, se um game-pad estiver conectado ao PC; Pings (RTT) – atual latência da rede sem fio.

Na seção Autopilot Status (2), temos informações sobre a fila de comandos, o último comando enviado e próximo na fila e informações sobre o próximo ponto alvo na trajetória (ou way point), de erro e de controle do nó drone_autopilot.

Na seção Stateestimation Status (3), temos informações sobre o mapeamento e localização estimados pelo nó drone_stateestimation e status da bateria do drone.

Na seção Control source (4), temos a opções de controle do AR.Drone (Keyboard, Joystick, Autopilot, None)

Na seção Send Commands (5), temos uma caixa texto exibindo o conteúdo dos comandos de um plano de voo. Essa é a sequencia de comandos que serão enviados para o drone durante a missão (se Autopilot estiver selecionada em Control source). Um plano de voo pode ser carregado a partir da lista em Load file:. Para estar disponível nesta lista, o arquivo deve estar no diretório “flightPlans/“. Logo abaixo desta seção (6), temos alguns botões para envio de comandos e limpeza da fila.

A última seção (Messages), exibe um log de mensagens relacionadas ao status nós sistema e dos comandos enviados ao AR.Drone.

drone_GUI

Exemplos de planos de voo podem ser encontrados em tum_ardrone/flightPlans/*.txt. Para usar o seu próprio plano de voo, basta criar um arquivo de texto (.txt), editá-lo com os comandos de voo e salvá-lo no diretório apropriado.

Um dos exemplos mais simples, que poderia ser utilizado como teste inicial é o autoInitAndLand.txt:

autoInitAndLand.txt

[sourcecode language=”text” wraplines=”false”]
autoInit 500 800

land
[/sourcecode]

A primeira linha inicia o AR.Drone e o faz decolar até uma altura aproximada de 1 metro. E a segunda faz com que ele aterrisse. Na dúvida, reveja os Principais comandos.

O exemplo square.txt já é um pouquinho mais complexos e pode ser usado para testar a realização de uma trajetória padrão: percorrer uma trajetória quadrada no céu.

square.txt

[sourcecode language=”text” wraplines=”false”]
autoInit 500 800

setReference $POSE$

setMaxControl 1

setInitialReachDist 0.2

setStayWithinDist 0.5

setStayTime 2

goto 0 0 2 0

goto 1 0 2 0

goto 1 0 0 0

goto -1 0 0 0

goto -1 0 2 0

goto 0 0 2 0

goto 0 0 1 0

land
[/sourcecode]

Os comandos setXXX, define parâmetros de configuração do voo (veja Principais comandos) :

setReference define a posição atual do drone como referência; setMaxControl define velocidade com que o drone fará a missão, quanto maior o valor, mais lento é movimento, a fim de proporcionar melhor controle sobre o movimento; setInitialReachDist define a distância máxima que o drone deve estar do ponto inicial, antes de iniciar a missão; setStayWithinDist define a distância mínima que o drone deve estar de um alvo, para que seja considerado alcançado dentro da missão; setStayTime define quanto tempo o drone deve permanecer dentro da distância definida por setStayWithinDist, para seja considerado alcançado. Os comandos goto indicam a posição alvo e a rotação no eixo z (x y z yaw) e land faz o AR.Drone aterrissar.

Essa ferramenta para a criação e execução de voos autônomos é um pouco mais complexa do que a que mencionamos no post anterior, mas ela oferece uma variedade de parâmetros que podem ser configurados para ajuste do controlador e do sistema de estimativa de estado do AR.Drone.

Referências

  1. http://www.ros.org/
  2. http://wiki.ros.org/
  3. http://pt.wikipedia.org/wiki/Licen%C3%A7a_BSD
  4. http://pt.wikipedia.org/wiki/Código_aberto
  5. http://wiki.ros.org/hydro/Installation/Ubuntu
  6. http://wiki.ros.org/hydro/Installation
  7. http://wiki.ros.org/hydro/Installation/Source
  8. http://wiki.ros.org/ardrone_autonomy
  9. https://code.google.com/p/brown-ros-pkg/wiki/ardrone_brown
  10. http://ardrone2.parrot.com/
  11. https://projects.ardrone.org/
  12. 12.   https://github.com/FalkorSystems/tum_ardrone
  13. 13.   http://wiki.ros.org/tum_ardrone/drone_stateestimation
  14. 14.   http://wiki.ros.org/tum_ardrone/drone_autopilot
  15. 15.   http://wiki.ros.org/tum_ardrone/drone_gui

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

*
*
Website