No post anterior, Voos Autônomos Com O Ar.Drone (Parte 2): ROS, vimos como utilizar o ROS para realizar voos autônomos com o Ar.Drone. Nesse novo post iremos executar os códigos em JavaScript pelo próprio drone bem como incluir novos sensores à ele.

Execução do código pelo drone.

Anteriormente, todos os códigos eram executados por computadores externos como, por exemplo, desktops, laptops ou até mesmo celulares. Para deixar o drone mais flexível de modo que não dependa de um dispositivo externo tornou-se necessário viabilizar a execução dos códigos pelo próprio drone. Nesse sentido o drone se tornaria menos dependente de outros dispositivos. Para realizar essa etapa foi necessário verificar uma maneira de conectar-se ao drone via WiFi que ele mesmo disponibiliza. Através de acesso TELNET, via IP: 192.168.1.1, foi possível acessar o Kernel Linux do Ar.Drone, como pode ser conferido na Figura 1. A partir do acesso ao Kernel pode-se ter acesso ao Sistema Operacional Linux embutido no Ar.Drone, utilizando o processador e a memória principal do drone para a execução de programas.
Após obter a conexão foi necessário realizar testes de execução de código em JavaScript no drone. Para isso foi fundamental seguir os passos:

1. Conectar o dispositivo (laptop, desktop ou celular) à rede wireless provida pelo próprio Ar.Drone.
2. Preparar o ambiente para a execução dos códigos em JavaScrip pelo Node.js. Nesse caso, para execução interna no drone, foi preciso copiar para um pendrive o executável do framework Node.js para Linux.
3. Incluir as bibliotecas ar-drone e ardrone-autonomy para Node.js ao drone.
4. Transferir os códigos em JavaScript também para um pendrive.
5. Executar os códigos utilizando os arquivos e o node contidos no pendrive.

Para acessar arquivos contidos no pendrive pelo drone basta acessar o diretório /data/video/usb0/. Na Figura 2 pode-se conferir a execução do Algoritmo 1 pelo próprio drone através do comando /data/video/usb0/./node testautonomy.js. Onde o arquivo node é o executável responsável por rodar o framework Node.js e testautonomy.js o arquivo com os comandos em JavaScript para a execução.

Algoritmo 1:

[sourcecode language=”JavaScript”]
var autonomy = require(‘ardrone-autonomy’);
var mission = autonomy.createMission();

mission.takeoff()
.zero()
.altitude(1)
.forward(2)
.right(2)
.backward(2)
.left(2)
.hover(1000)
.land();

mission.run(function (err, result) {
if (err) {
console.trace("Oops, something bad happened: %s", err.message);
mission.client().stop();
mission.client().land();
} else {
console.log("Mission success!");
process.exit(0);
}
});
[/sourcecode]

 

Inclusão de sensores ao Ar.Drone, utilizando Arduino

O Parrot Ar.Drone possui um conjunto de sensores disponíveis, porém torna-se necessário a inclusão de mais sensores a fim de coletar maiores informações sobre o ambiente. Para tornar voos autônomos viáveis é imprescindível a utilização de sensores e a escolha de quais sensores utilizar. Para o planejamento do voo dependerá do objetivo a ser conquistado. Pensando nisso torna-se necessária a inlusão de mais sensores ao drone.
A estratégia utilizada foi viabilizar a inclusão de uma board Arduino ao Ar.Drone. Dessa maneira seria possível incluir sensores ao Arduino e obter os dados sensoriais pelo drone, realizando uma leitura dos mesmos pela porta USB contida na parte de baixo do Ar.Drone.

Os passos realizados para realizar esse cenário foram:

1. Identificar e entender as conexões USB da parte inferir do drone.
2. Criar um código simples para rodar no Arduino. Nesse caso foi a escrita na porta serial de uma string Hello World.
3. Incluir a biblioteca node-serialport ao drone para a leitura dos dados enviados pelo Arduino ao drone mediante a porta serial.
4. Implementar o código de leitura em JavaScript para a leitura dos dados.
5. Conectar o Arduino ao drone.
6. Verificar a leitura, executando os códigos implementados.

A empresa Parrot, fabricante do Ar.Drone, não fornece informações detalhadas sobre o hardware do drone, ainda, não fornece a descrição da porta USB o que levou a um trabalho de tentativa e erro. Após o entendimento da porta USB foi possível conectar o Arduino ao drone. A descrição da porta USB pode ser verificada na Figura 3 e o esquema de conexão na Figura 4. Vale lembrar que a porta USB do drone possui 4 (quatro) pinos, sendo:

• Rx: Para receber os dados enviados pela porta. Correspondente ao Pino 3 e dever ser conectado ao Pino Tx do Arduino.
• Tx: Para enviar os dados. Correspondente ao Pino 5 e dever ser conectado ao Pino Rx do Arduino.
• Ground: O aterramento. Correspondente ao Pino 8 e dever ser conectado ao Pino Ground do Arduino.
• Vcc 5v: Fonte de alimentação de corrente contínua com tensão de 5 volts. Correspondente ao Pino 9 e dever ser conectado ao Pino Vin do Arduino.

 

 

Vale lembrar que o Rx do Arduino deve ser conectado ao Tx do drone e o Tx do Arduino ao Rx do drone uma vez que um pino envia e o outro deve receber. Ainda, o pino Vcc do drone deve ser conectado ao Vin do Arduino de modo que o Vin é a fonte de alimentação de corrente contínua da board.

Após realizar todos os passos de preparação do ambiente de modo que o Ar.Drone possa se comunicar com o Arduino o código referente ao Algoritmo 2 de teste Hello World foi executado no Arduino por meio de uma sequência de códigos em JavaScript utilizando a biblioteca node-serialport do framework Node.js. No Algoritmo 3 pode ser conferido o código responsável pela leitura da porta serial, /dev/ttyO3, pelo Ar.drone. O resultado da leitura pelo drone por ser conferido na Figura 5.

Algoritmo 2:

[sourcecode language=”c”]
void setup(){
Serial.begin(9600);
}

void loop(){
Serial.println("Hello World");
delay(100);
}
[/sourcecode]

Algoritmo 3:

[sourcecode language=”JavaScript”]
var serialport = require(‘node-serialport’)

var sp = new serialport.SerialPort("/dev/ttyO3", {
parser: serialport.parsers.raw,
baud: 9600
})

sp.on(‘data’, function(chunk) {
console.log(chunk.toString())
})
[/sourcecode]

 

Até este ponto mostra-se possível a comunicação do Arduino com o Ar.Drone uma vez que a board escreve na porta serial de saída (Tx) a string Hello World. Assim o Ar.Drone, mediante o Algoritmo 2 de leitura da porta serial recebe a string pela entrada serial (Rx), imprimindo-a no terminal de comando do drone.

O próximo passo é incluir sensores na board Arduino de modo que o drone possa receber os dados sensoriais enviados pela board. Para exemplificar a inclusão de dados sensoriais foi incluído um sensor de temperatura, LM35, ao Arduino, conforme pode ser verificado o esquema de conexões na Figura 6. O código responsável pela leitura do sensor pelo Arduino é mostrado no Algoritmo 4. A variável correctFactor é o fator de correção calculado para a utilização do sensor de temperatura pelo drone uma vez em que há diferenças de voltagem na fonte de alimentação do drone e da porta USB de um computador convencional. Para calcular esse fator foi coletado uma amostra de 30 valores, isto é, resultados de temperatura do sensor utilizando como fonte de alimentação do Arduino a porta USB de um computador. Em seguida foi coletada a mesma quantidade de amostra com fonte de alimentação sendo o drone. Logo o fator de correção é a divisão da média aritmética dos resultados coletados pelo drone pela média coletada pelo computador. Na Figura 7 pode-se verificar a leitura do sensor de temperatura, em graus, conectado ao Arduino, pelo drone, executando o Algoritmo 3 pelo drone através do comando /data/video/usb0/./node serial3.js. Na Figura 8 podemos conferir o conjunto de conexões final, ou seja, o sensor de temperatura LM35 conectado ao Arduino e o próprio Arduino conectado ao Ar.Drone.

Algoritmo 4:

[sourcecode language=”c”]
int analTempPin = A0;
float temp = 0;
float correctFactor = 0.768744354;

void setup(){
Serial.begin(9600);
}

void loop(){
temp = analogRead(analTempPin);
temp = ((5.0 * correcFactor) * temp * 100.0)/1024.0;
Serial.println(temp);
delay(200);
}
[/sourcecode]

 

 

 

Observações

Este projeto é conteúdo da Monografia: Johnnatan Messias; Framework para Sistemas de Navegação de Veículos Aéreos Não Tripulados; Monografia; 2014 (Link em breve)

Referencias:

• Johnnatan Messias; Framework para Sistemas de Navegação de Veículos Aéreos Não Tripulados; Monografia; 2014 (link)
• J. Postel and J. Reynolds; TELNET Protocol Specification. Internet STD 8, RFC 854; 1983