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:
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:
fercic@ubuntu:~$ rosrun ardrone_autonomy ardrone_driver
[/sourcecode]
Ao rodar este nó,
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.
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
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
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
- http://www.ros.org/
- http://wiki.ros.org/
- http://pt.wikipedia.org/wiki/Licen%C3%A7a_BSD
- http://pt.wikipedia.org/wiki/Código_aberto
- http://wiki.ros.org/hydro/Installation/Ubuntu
- http://wiki.ros.org/hydro/Installation
- http://wiki.ros.org/hydro/Installation/Source
- http://wiki.ros.org/ardrone_autonomy
- https://code.google.com/p/brown-ros-pkg/wiki/ardrone_brown
- http://ardrone2.parrot.com/
- https://projects.ardrone.org/
- 12. https://github.com/FalkorSystems/tum_ardrone
- 13. http://wiki.ros.org/tum_ardrone/drone_stateestimation
- 14. http://wiki.ros.org/tum_ardrone/drone_autopilot
- 15. http://wiki.ros.org/tum_ardrone/drone_gui