AR.Drone: Imagine um mundo onde Robôs voam por aí, seja para acompanhar um repórter, usos militares, mapeamento de um determinado território ou até mesmo para tirar simples fotos de certa altura da Terra. Pois é, o nome dessas máquinas é VANT (Veículo Aéreo Não Tripulado), UAV (Unmanned Aerial Vehicle) ou simplesmente drone. São Robôs que voam com grande capacidade de processamento, sendo cada vez mais potentes sem a necessidade de um piloto a bordo.

Existem diversos modelos de VANTs no mercado, porém, nós do iMobilis, escolhemos devido ao baixo custo, o AR.Drone da Parrot, um quadricóptero, ou quadrotor, apresentado ao mundo na CES 2010 (Consumer Eletronics Show), uma feira de eletrônicos mundiais onde os fabricantes exigem seus produtos inovadores ao mundo. Em 2012, também na CES, a Parrot apresenta ao mundo a versão 2.0 do AR.Drone com inúmeras melhorias conforme será explicado no decorrer do post.

O AR.Drone possuiu quatro hélices, pode ser controlado por computadores, smartphones ou tablets, ficou muito conhecido a partir do seu lançamento devido ser um drone de baixo custo e não letal de modo a ser utilizado tanto pela academia, em pesquisas científicas, quanto para crianças passando-se, para elas, como um simples brinquedo que voa controlado pelo celular ou até mesmo para os fotógrafos profissionais quando o assunto é tirar uma foto nas alturas.

Abaixo podemos conferir as diferenças visuais do AR.Drone 1.0 (esquerda) e do AR.Drone 2.0 (direita).

Algumas das principais características podemos verificar na tabela abaixo:

Podemos notar que o AR.Drone 2.0 obteve um aprimoramento no hardware, aumentando o seu poder computacional. Sem dúvidas o ajudou muito, porém devemos olhar mais atentamente em seus sensores, que são muito úteis para o drone, são eles:

• Câmera vertical: Útil para visualizar o solo e ainda, através de um algoritmo de comparação de imagens mede a velocidade do voo.
• Câmera frontal: Útil para controla-lo a distância bem como temos acesso a ela quando o assunto é desenvolvimento para efetuarmos técnica de mapeamento e localização utilizando SLAM.
• Ultrassom: Possui dois sensores de ultrassom para medir a altura do VANT.
• Sensor de Pressão*: ótimo para dar mais estabilidade durante os voos verticais.
• Giroscópio: Útil para obter a direção do drone.
• Acelerômetro: Para medir a força aplicada ao trone, informando a sua inclinação num determinado eixo.
• Magnetômetro: Uma bússola 3D, útil no Absolute Control.
• Absolute Control*: Recurso interessante no AR.Drone 2.0 pois, através do magnetômetro podemos controlar o quadricóptero colocando como referencial o ponto referencial de visão do usuário.

* Presente somente no AR.Drone 2.0

E então, quais são as vantagens para os desenvolvedores?

Bom, como vantagens, podemos citar:

• Source code e API disponíveis
• Kernel Linux
• Documentação SDK
• Baixo custo

Claro que há desvantagens quando observamos que não há uma documentação adequada sobre a parte elétrica do hardware do drone e nem sobre o firmware rodando dele.

O modelo dinâmico do drone é descrito mediante as leis de Newton e Euler. O momento inercial é calculado assumindo que o quadricóptero pode possuir em seu centro uma esfera de raio r e massa M0 suportando quatro outras massas, os motores no caso. Considerando que cada motor tem a massa m e estão anexados ao centro por um eixo de tamanho l. Este modelo pode ser visto na figura abaixo.

E na figura abaixo podemos ver as claramente as forças atuantes, torque, empuxo, peso:

Modelo de movimentação

Hover:

Na figura abaixo temos o modelo esquemático da estrutura do drone em preto. Em verde e azul podemos ver a velocidade angular das hélices.

Nesse modelo as hélices giram na mesma velocidade () de modo a deixar o drone estacionado no ar.

Throttle:

Esse movimento é obtido mediante a variação de velocidade das hélices, ou seja, incrementando ou decrementando a velocidade das hélices em algum valor. Movimento esse responsável pela movimentação vertical do quadricóptero.

Em azul está especificado a velocidade das hélices com possuem a mesma velocidade () .

Roll:

Para esse movimento é necessário alterar as velocidades das hélices direita (Right) e esquerda(Left).

Movimento responsável por fazer o AR.Drone inclinar-se para direita ou esquerda.

Pitch:

Similares ao Roll, entretanto, nesse movimento modificam-se as velocidades das hélices com valores contrários. Responsável por fazer o drone ir para frente ou para trás.

Yaw:

Por fim, temos o movimento Yaw, onde alteramos as velocidades das quatro hélices. Notamos, através do modelo, que as hélices esquerda (Left) e direita (Right) são incrementadas com valores positivos () enquanto as frente(Front) e trás (Rear) são decrementadas com valor (). Esse movimento é responsável por fazê-lo girar sobre o seu próprio eixo.

A AR.Drone usa quatro motores conectados às 4 hélices, logo a equação do sistema é descrita abaixo:

Onde:

• JP é o momento inercial do rotor em torno do eixo da hélice.
• JM é o momento inercial em torno do eixo do motor
• KE, KM são constantes que tem algum valor, mensurado em diferentes unidades.
• Wp é a velocidade das hélices.
• R é a resistência do motor.
• N pode ser calculado como a razão entre o número de dentes da engrenagem da hélice com o número de dentes da engrenagem do motor.
• ɳ Ou eficiência de conversão é ligada a energia mecânica da PM do eixo do motor para o eixo da hélice.
• V é a voltagem de entrada do motor.
• PM é a potência do motor.

Abaixo podemos verificar a máquina de estados do AR.Drone.

Para exemplificação realizamos a implementação de um código em Java, utilizando o JavaDrone, para a leitura dos sensores disponíveis no Ar Drone 1.0.

Classe Ardrone:

Classe principal para a execução do nosso código de exemplo. Vide comentários no próprio código.

[sourcecode language=”java”]
public class Ardrone {
private static ARDrone drone;
public static void main(String[] args) {
try {
drone = new ARDrone();

System.out.println("Connect");
drone.connect(); //Inicia a conexão com o Ar Drone

System.out.println("clearEmergencySignal");
drone.clearEmergencySignal();

System.out.println("waitForReady");
drone.waitForReady(3000);

System.out.println("trim");
drone.trim(); //Configura o Ar Drone para estabilizagem no ar

Sensores sensores = new Sensores("sensorLog.txt");
drone.addNavDataListener(sensores); //Uma Thread é criada para a geração dos logs

System.out.println("Takeoff");
drone.takeOff(); //Inicia a decolagem do Ar Drone

Thread.sleep(50000); //Faz com que o Ar Drone voe por 50 segundos

System.out.println("Land");
drone.land(); //Faz com que o Ar Drone inicie o procedimento de pouso

Thread.sleep(2000); //Aguarda-se 2 segundos para a realização total do pouso
System.out.println("Disconnect");
sensores.closeFile();
drone.disconnect(); //Encerra a conexão com o Ar Drone
} catch (InterruptedException ex) {
Logger.getLogger(Ardrone.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(Ardrone.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
[/sourcecode]

Classe Sensores:

Classe responsável por implementar a interface NavDataListener e ainda por gerar os Logs dos sensores do ArDrone.

[sourcecode language=”java”]
public class Sensores implements NavDataListener {
private String datas;
private String printFile;
private PrintWriter printWriter;

public Sensores(String fileName) {
try {
printWriter = new PrintWriter(fileName);
printWriter.write("Timestamp;Bateria;Altitude;Vy;"
+ "Pitch;Roll;Sequence;Vx;Vz;Yaw" + "\n");
} catch (FileNotFoundException ex) {
Logger.getLogger(Sensores.class.getName()).log(Level.SEVERE, null, ex);
}
}

@Override
public void navDataReceived(NavData nd) {

datas = "Bateria=" + nd.getBattery() + "%" + "\t"
+ "Altitude=" + nd.getAltitude() + "\t" + "Vy="
+ nd.getLongitude() + "\t" + "Pitch="
+ nd.getPitch() + "\t" + "Roll=" + nd.getRoll()
+ "\t" + "Sequence=" + nd.getSequence() + "\t"
+ "Vx=" + nd.getVx() + "\t" + "Vz=" + nd.getVz()
+ "\t" + "Yaw=" + nd.getYaw();

printFile = getTimestamp() + ";" + nd.getBattery() + ";"
+ nd.getAltitude() + ";"
+ nd.getLongitude() + ";"
+ nd.getPitch() + ";" + nd.getRoll()
+ ";" + nd.getSequence() + ";"
+ nd.getVx() + ";" + nd.getVz()
+ ";" + nd.getYaw();
printWriter.write(printFile + "\n");
System.out.println(datas);
}

public PrintWriter getFile() {
return printWriter;
}

private String getTimestamp() {
Date date = new Date();
String dateTimestamp = String.valueOf(date.getTime() / 1000);
return dateTimestamp;
}

public void closeFile() {
printWriter.close();
}
}
[/sourcecode]

Resultados:

Através da coleta dos dados dos sensores realizamos a plotagens dos gráficos de Altitude, Roll, Pitch, Vx, Vy, Vz e Yaw.

Altitude: Basicamente mede o comportamento do estado Throttle uma vez que dependendo da variação da rotação de todas as hélices com a mesma velocidade, sendo um acréscimo ou decréscimo, o VANT terá sua altura variada conforme verificamos no gráfico resultante do código descrito acima.

Roll: O gráfico abaixo representa o movimento responsável por fazer o AR.Drone inclinar-se para direita ou esquerda. Sendo a parte positiva do gráfico representando o movimento para a direita e a negativa a esquerda.

Pitch: Similares ao Roll, entretanto, esse movimento é responsável por fazer o drone ir para frente(parte positiva) ou para trás(parte negativa).

Yaw: Esse movimento é responsável por fazê-lo girar sobre o seu próprio eixo.

Vários trabalhos estão em desenvolvimento sobre VANTs e através da leitura de artigos pude observar técnicas de visão computacional empregados no AR.Drone como, por exemplo, SLAM (Simultaneous Localization and Mapping), SURF (Speed Up Robust Feature) e o ROS (Robot Operating System).

SLAM:

Técnica utilizada pelos robôs autônomos para mapear um ambiente e localiza-se dentro desse ambiente simultaneamente. Para melhor exemplificação de SLAM, podemos citar o vídeo:

SURF:

O SURF é um descritor de características, inspirado parcialmente no SIFT, visando um menor custo computacional com boa performance.

ROS:

Provê um conjunto de bibliotecas que auxiliam no desenvolvimento de softwares voltados à robótica. Facilita a integração do AR.Drone com o Kinect da Microsoft. Possui pacotes para SLAM implementados.

Conclusão:

Os VANTs proporcionam a fusão de várias áreas de pesquisa, desde a concepção do robô, a física para mantê-lo no ar, até o hardware e software.

Há inúmeros trabalhos sendo desenvolvidos, a boa notícia é que podemos dizer confiantemente sobre a importância deles para o mundo bem como há muito no que se pensar e fazer em termos de pesquisa e indústria.

Podemos utilizar no AR.Drone, o ROS, OPENCV para extração de informações do ambiente através das câmeras e sensores para a missão de um futuro voo autônomo.

Download:

Source Code (link).

Referências:

1. Berezny, N., Greef, L., Jensen, B., Sheely, K., Sok, M., Lingenbrink, D. and Dodds, Z. (2012). Accessible Aerial Autonomy. In IEEE. (link)
2. Bristeau, P.J., Callou, F., Vissière, D. and Petit, N. (2011). The Navigation and Control technology inside the AR.Drone micro UAV. In 18th IFAC World Congress. (link)
3. Morar, I.R. and Nascu, I. (2012). Model Simplification of an Unmanned Aerial Vehicle. In IEEE. (link)
4. T. Bresciani: Modelling, Identification and Control of a Quadrotor Helicopter, Department of Automatic Control, Lund University, 2008. (link)
5. http://users.isr.ist.utl.pt/~vale/presentations/slam_pres/SLAM_2002_KTH.pdf
6. http://en.wikipedia.org/wiki/Simultaneous_localization_and_mapping
7. http://www.ros.org/wiki/
8. http://en.wikipedia.org/wiki/SURF
9. http://code.google.com/p/javadrone/