Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Engenharia Informática
2012/2013
ii
Navegação Autónoma em Robôs Aéreos
Relatório da UC de Projeto
Licenciatura em Engenharia Informática
Escola Superior de Tecnologia e Gestão
___________________________________________
___________________________________________
___________________________________________
Arguente
Neste projeto foi desenvolvido um sistema de navegação autónoma num robô chamado
ARDrone (a partir daqui passará a ser chamado apenas de “Drone”) que é um quadricóptero
fabricado pela empresa francesa Parrot. O objetivo do sistema de navegação autónoma é fazer
o Drone aterrar num ponto específico previamente definido por nós.
Utilizando a imagem recebida pela câmara inferior e pela câmara frontal, foi desenvolvido um
algoritmo de navegação que permitiu ao Drone ter um movimento autónomo, fazendo a
junção do processamento de imagem com um sistema de navegação autónoma.
O sistema de navegação autónoma é executado num computador que está ligado ao Drone via
wireless, ou seja, o Drone é controlado remotamente pelo nosso computador.
Neste trabalho usou-se a linguagem java. Foi escolhida esta linguagem pois, embora não fosse
a mais indicada para processamento de imagem, era aquela em que se encontrava mais
informação na internet, e por ser de fácil compreensão.
Palavras-chave:
In our project we built a system of autonomous driving a robot named ARDrone (from here
will be just called "Drone") which is a quadricopter manufactured by French company Parrot.
The goal of autonomous driving system is doing Drone landing at a specific point previously
defined by us.
Using the image received by the lower camera and the front camera, an algorithm was
developed that allowed the Drone have an autonomous movement, makings the junction of
image processing with a system of autonomous navigation.
In the navigation system is built an algorithm that allowed the displacement autonomous
Drone.
The autonomous navigation system runs on a computer that is connected via wireless to
Drone, or the drone is controlled remotely by our computer.
In this work we used to java language. This language was chosen because, although it was not
the most suitable for image processing, was that it was in more information on the internet,
and be easy to understand.
The elaboration of our project involved networking concepts, image processing, object
oriented programming and mathematics.
Keywords:
xiv
Lista de Tabelas
xvi
xvii
Lista de Figuras
xviii
Figura 39- Definição da altitude máxima .............................................................................................. 49
Figura 40- Definição de valores da velocidade ..................................................................................... 49
Figura 41- Ambiente Gráfico da aplicação de controlo com o computador.......................................... 50
Figura 42- Condição de aterrar verificada ............................................................................................. 51
Figura 43-Exemplo do Drone no modo de navegação autónoma com a câmara inferior .................... 52
Figura 44- Gráfico do erro desde que deteta folha até aterrar ............................................................... 53
Figura 45- Como é calculado o "erro" ................................................................................................... 54
Figura 46- Exemplo de funcionamento da navegação com a câmara frontal ........................................ 55
xix
1
Capítulo 1
1 Introdução
Neste capítulo irá ser apresentada uma introdução á área multidisciplinar que é a
robótica, referindo as diversas atividades em que ela está presente no nosso dia-a-dia,
referindo os objetivos e a motivação para realizar este projeto.
1.1 Contextualização
Numa segunda fase, a pesquisa tem sido a construção de robôs móveis, introduzindo
algumas novidades tais como a mobilidade e a autonomia para reagir adequadamente ao
ambiente circulante, o que criou um vasto leque de novas aplicações e por consequente
um número ainda maior de novos desafios. São várias as aplicações que são realizadas
em torno da robótica. As aplicações vão desde as que de alguma maneira substituem o
2
trabalho do homem, em tarefas repetitivas e onde o erro é quase nulo, até as aplicações
que servem de auxilio ao homem, quer seja em tarefas como a vigilância, ou a operação
em ambientes hostis, ou até mesmo em auxilio a pessoas inválidas ou idosas. Como o
exemplo do Rocky 4 (Figura 1), com dimensões reduzidas, foi capaz de explorar á
distância o planeta Marte. Este robô foi controlado a partir da Califórnia, e cada imagem
demorava apenas dez minutos a chegar ao planeta Terra. [1]
Figura 1- Rocky 4
3
(LCAR), com o nosso sistema de navegação. Como este robô aéreo comunica via
wireless, transmitindo informações sobre o seu estado como o vídeo captado pelas suas
câmaras é possível ligar este robô a um computador e assim processar as imagens
recebidas enviando de volta ações que o robô deve tomar, essas ações devem ser
decididas pelo sistema de navegação sendo completamente autónomo, isto é sem
qualquer intervenção humana.
4
5
Capitulo 2
6
programação, possíveis obstáculos que se apresentem pela frente, etc. Logo conclui-se
que fazer com que um robô tenha o desempenho desejado não é uma tarefa fácil. Os
problemas mais comuns são os seguintes:
7
Normalmente são distinguidos e agrupados em três categorias, anatomia, tipo de
controlo, e funcionalidade. Na área da anatomia existem três diferentes tipos de robôs
que são: terrestres, aéreos e aquáticos. (Figura 3)
Os robôs aéreos são veículos não tripulados que se movem no ar (aviões, helicópteros
ou dirigíveis) e que são operados remotamente ou executam funções de forma
autónoma. Podem desempenhar várias funções tais como reconhecimentos e
monitorização de regiões remotas ou fronteiras, reconhecimento tácito e apoio
operacional em missões e atividades miliares, deteção de incêndios e suporte á sua
extinção. (Figura 4Erro! A origem da referência não foi encontrada.)
Figura 4-Robô aéreo usado como plataforma aérea para câmaras [4]
8
Na Figura 5 apresenta um exemplo de um robô que faz a patrulha e monitorização de
fronteiras.
Os robôs terrestres são os mais comuns. São robôs que se movem em terra e são muito
utilizados para substituir os humanos em tarefas perigosas como por exemplo o
desarmamento de bombas e exploração planetária. (Figura 6)
Figura 6-- Robô terrestre usado pela NASA para obter amostras do solo de Marte [6]
9
Os bípedes (robôs de duas pernas) são tentativas de reproduzir o modo de locomoção do
próprio ser humano, o que permite a sua interação em ambientes feitos para uso
humano, por exemplo o caso do Twendy-One (Figura 7), que é um robô que tem a
capacidade de amparar pessoas para que elas se levantem ou sentem, segurar objetos de
forma cuidadosa e reagindo agilmente a alguns comandos. [7]
Outro exemplo de um robô humanoide é o Robonaut 2 (Figura 8), que foi criado pela
NASA, e enviado para uma estação espacial para assumir tarefas perigosas para os
astronautas.
10
Os robôs aquáticos funcionam dentro de água e são mais utilizados para buscas em
regiões de alta profundidade e pressão. São muito usados no estudo dos fundos
oceânicos e para a retirar materiais desses locais, bem como na monitorização em
oleodutos, como por exemplo o SuperGNOM Pro (Figura 9) criado especificamente
para inspecionar objetos submersos, como por exemplos naufrágios ou construções
subaquáticas pode ser equipado com um manipulador para mover objetos ou com um
sonar para fazer varrimento da área, consegue atingir profundidades de 300 metros,
mover se em ambos os sentido, horizontal e vertical devido aos seus propulsores e é
controlado a partir da unidade de controlo que se encontra na superfície.
O Kingfish (Figura 10) é outro exemplo de um robô aquático, tendo sido usado pela
marinha americana para monitorizar o Golfo Pérsico, com o principal objetivo de
destruir minas. É usado também na busca e deteção de objetos. [9]
11
2.2 Robôs Aéreos
Um robô aéreo ou Unmanned Aerial Vehicules (UAV’s) é uma aeronave que não
necessita de um piloto, navegando de forma autónoma usando uma aplicação
computacional. No início da sua história eram simples aviões pilotados remotamente
tendo como principal objetivo fins militares, mas na atualidade com o avanço da
tecnologia são cada vez mais autónomos devido a incorporem uma variedade de
sensores, tais como: GPS, giroscópio, acelerómetro, bússola, sensor de referência á
altitude, entre outros, também equipados com camaras obtendo assim uma melhor
perceção do ambiente que o rodeia. Os UAV’s podem ser divididos em duas categorias,
nomeadamente, asas fixas, e asas rotativas.
Os UAV’s de asas fixas são por norma mais rápidos mas têm restrições relacionadas
com a manobrabilidade, não conseguem pairar, isto é, permanecer imoveis numa
determinada posição por longos períodos de tempo, enquanto os UAV’s de asas
rotativas mais conhecidos por quadricópteros conseguem, como também descolam e
aterram na vertical, não precisando de grandes superfícies planas para o fazer.
Estes robôs têm como finalidade as mais diversas catividades, tais como:
12
dos primeiros UAVs usados para salvar vidas. Este robô é todo construído em fibra de
carbono.
O Elbit System (Figura 12) é um UAV fabricado pela Israelense Elbit Systems, é
projetado para longas missões táticas de resistência. Tem uma autonomia de mais de 20
horas, com a missão primária de vigilância, reconhecimento e retransmissão de
comunicações. O robô tem um comprimento de 6.1 metros, uma envergadura de 10,5
metros e um peso total de 15 kg, atinge uma velocidade máxima de 176 km/h e tem um
alcance de 200km. [12]
13
O MQ-1 Predator (Figura 13) é também um UAV desenvolvido pela empresa General
Atomics para a Força Aérea dos Estados Unidos, tem capacidade para transportar armas
ou sensores para vigilância.
O veículo tem um comprimento de 8,22 metros e uma altura de 2,1 metros, com um
peso total de 512kg e suporta um peso máximo de 1020kg, atinge uma velocidade
máxima de 217km/h e tem um alcance de 3.705 km com uma autonomia de 24 horas.
[10]
A navegação autónoma consiste em mover um robô de um ponto até outro sem qualquer
tipo de intervenção humana, assegurando todo o tipo de segurança tanto ao robô como
ao seu redor. Para isso acontecer o robô necessita de responder a varias questões
importantes no âmbito da navegação a si próprio, tais como, “para onde vou?”, “onde
estou?”, “onde estive?”, “como posso chegar lá?”. O robô necessita de ter vários
sensores, atuadores, métodos de processamento de informação e inteligência artificial,
para que o próprio se consiga aperceber do ambiente que o rodeia, e assim consiga
tomar as decisões corretas para cada tipo de situação (Figura 14).
14
Figura 14-Exemplo de um algoritmo de navegação autónoma
15
16
Capitulo 3
17
Figura 16- Forças que atuam sobre o Drone
Ao usar diferentes velocidades em ambos os motores foi possível obter as forças que
são necessárias para movimentar o quadricóptero.
O movimento Hover é caracterizado por ter as quatro hélices a rodar com a mesma
velocidade fazendo com que ele paire no ar, tal como ilustrado na Figura 17.
O movimento Roll é conseguido através da variação das velocidades das hélices direita
(Right) e esquerda (Left). Este movimento faz com que o Drone se desloque para a
direita ou para a esquerda (Figura 18).
18
Figura 18- O movimento Roll
19
O movimento de Throttle é conseguido através da variação da velocidade das quatro
hélices em simultâneoEste movimento faz com que o Drone se desloque verticalmente
(Figura 21).
Este dispositivo dispõe de quatro motores que alimentam as asas rotativas, e duas
câmaras, uma horizontal e uma vertical que captam o ambiente onde o veículo se
desloca. Ambas possuem um sensor CMOS [14] . A câmara frontal tem um ângulo de
visão de 90 graus com uma resolução de 320 por 240 pixels, codifica e transmite para o
dispositivo a 15 frames por segundo. A câmara frontal pode ser usada também para
detetar outros Drones, devido às marcas que se encontram na carcaça do Drone (Figura
22), possibilitando jogos em multiplayer ou para se poder orientar no meio ambiente.
20
Figura 22-Identificadores para reconhecimento
Quanto á câmara inferior, esta tem um ângulo de visão de 64 graus e possui uma
resolução de 176 por 144 pixels, e codifica e transmite para o dispositivo a 64 frames
por segundo. O Drone faz uso da câmara inferior para se estabilizar quando está a pairar
e para ter uma estimativa da velocidade que se encontra. O Drone tem vários sensores
que estão fixados na placa principal (Figura 23), como um acelerómetro e um
giroscópio, esses sensores fornecem ao programa interno dados sobre o pitch, roll e
yaw, o que permite ao Drone controlar movimentos como, inclinação, rotação e
estabilização automática.
O Drone contém também um sensor ultrassom (Figura 24) que se encontra na parte
inferior do Drone usado para saber a distância o Drone se encontra do chão ou de outro
objeto que se encontre por baixo, conseguindo medir até uma altura máxima de 6
21
metros. O Drone utiliza esse sensor para se manter sempre a mesma distância depois de
descolar e para fazer uma aterragem suave, descendo lentamente parando os motores
quando estiver no chão.
O Drone consegue atingir velocidades até 18km por hora, voa até uma altitude máxima
de 6 metros, e tem um alcance de 50 metros. É possível pilotá-lo em dois modos, o
indoor e o outdoor (Figura 25). No modo indoor as suas dimensões são de 52.5cm x
51.5cm, com um peso de 420g, e no modo outdoor são de 45cm x 49cm e um peso de
380g.
A Parrot lançou entretanto uma nova versão do AR.Drone, a versão 2.0, que é uma
versão com bastantes melhoramentos, principalmente a nível de hardware. As
diferenças entre o ARDrone 1.0 e o ARDrone 2.0, ambos existentes no Laboratório de
Controlo, Automação e robótica, encontram-se descritas na Tabela 1.
22
Tabela 1- Comparativo entre AR.Drone 1.0 e AR.Drone 2.0
23
No comando AT* REF composto por 32 bits em que os bit de 0 a 7 não são usados, o
bit 8 informa o Drone se está em modo emergência ou não, se este modo for
selecionado e se este bit for enviado a 1 o Drone entra em modo de emergência, os
motores vão parar automaticamente o que levará o Drone a uma queda violenta, o bit 9
informa o Drone se é para descolar ou aterrar, se o bit for enviado a 1 o Drone sabe que
é para descolar caso contrario e bit é enviado a 0 e Drone sabe que é para aterrar, os bits
restante também não são usados.
O comando AT* PCMD usa simplesmente os primeiros 2 bits, em que o bit 0 indica se
vai receber valores para movimentar o Drone, isto é se deve aceitar os valores roll pitch,
gaz e yaw, se esse bit for enviado a 0 o Drone não irá aceitar esses valores e entra em
modo de pairar automaticamente, enquanto o bit 1 vai informar o Drone se deve aceitar
o valor do argumento yaw, isto é se o bit for enviado a 0 o Drone aceita o valor de yaw e
que possibilitará ao Drone girar em torno de si próprio na mesma posição, enquanto se o
bit for enviado a 1 o Drone não irá aceitar o valor de yaw e calculará automaticamente
esse valor dependendo dos outros valores.
O comando AT* CONFIG é usado para configurar o Drone, definições como a da altura
máxima, altura mínima ou valores que se quer receber do Drone, como por exemplo
vídeo, versão de software entre outros são configurados com este comando.
24
criada automaticamente pelo Drone, e a comunicação é feita através de sockets,
enviando um conjunto de AT Commands.
O Drone cria uma rede wireless com um ESSID normalmente chamado de ardrone_xxx.
O Drone envia informações através de 4 portas:
25
26
Capitulo 4
Neste capítulo será abordado o tema do processamento de imagem. Irão ser explicados
os métodos usados para adquirir a imagem do Drone, e para fazer o seu processamento
até serem dadas as instruções para o módulo de navegação autónoma.
A visão artificial é o tratamento digital de uma imagem fornecida por uma câmara, para
identificar objetos e determinar uma determinada localização e geometria.
Esta área da robótica pode ser caracterizada como imatura e diversa. Apesar de
existiram trabalhos já reconhecidos, somente após o final da década de 70 começaram
os estudos mais aprofundados, pois foi nessa altura que os computadores começaram a
processar grandes conjuntos de dados como imagens. No entanto tais estudos surgiram
devido a outros campos de pesquisa, e consequentemente não existe uma formulação
padrão para o problema da visão artificial, assim como não existe um padrão de
resolução dos problemas de visão artificial [15].
Para que o nosso principal objetivo fosse realizado com sucesso foi necessário
implementar um algoritmo que fosse responsável pelo processamento da imagem
(Figura 26).
27
Figura 26- Algoritmo usado no processamento da imagem
Logo após ser recebida a imagem é feita a sua conversão para níveis de cinzento, depois
são procurados os pontos mais claros da imagem, e identifica-se quais os pixéis a que
eles correspondem, e depois é feita uma nova imagem com esses pixéis a branco, e os
restantes a preto. Em seguida identifica-se se o conjunto dos pontos brancos se encontra
no centro da nossa imagem, e caso não esteja, são enviados os valores correspondentes
ao erro da mesma ao centro da imagem, para que no módulo de navegação sejam
enviados os comandos para que o Drone se movimente na direção necessária.
28
Figura 27- Divisão da imagem em grupos de blocos
Cada macro bloco contém informação da imagem no formato Y CBCR, do tipo 4:2.0
(1)
29
Figura 29- Conversão da Imagem para cinzento
Depois de convertida a imagem para cinzento são analisados todos os pixéis de modo a
saber-se quais os que contêm os valores mais elevados, pois são esses que interessam,
uma vez que o pretendido é saber a localização do ponto ou pontos mais brilhantes da
imagem.
DataBuffer b = image.getRaster().getDataBuffer();
int n = b.getSize();
int array[] = new int[n];
for (int i = 0; i < n; i++) {
array[i] = b.getElem(i); }
return array;
Depois de conhecido qual o valor mais alto do array, é necessário ver quais são os
pixéis da imagem que contêm esse valor, e para isso é usada a função findIndex(),
descrita a seguir:
DataBuffer b = image.getRaster().getDataBuffer();
ArrayList<Integer> a = new ArrayList<>(20);
int j = 0;
for (int i = 0; i < b.getSize(); i++) {
if (b.getElem(i) >= value) {
a.add(i);
j++;
}
}
int array[] = new int[a.size()];
30
for (int k = 0; k < a.size(); k++) {
array[k] = a.get(k); }
Nesta função entram como parâmetros a imagem, e o valor mais elevado do nosso array,
que será o valor dos pontos mais brancos da imagem. Depois faz-se uma pesquisa em
todos os pixéis da imagem para procurar quais os são considerados os mais claros, e é
retornado um array contendo as posições da imagem que contêm esse valor.
Após serem conhecidos os pixéis com mais claridade da nossa imagem, é criada uma
nova imagem com todos os pontos a preto, e a branco os pontos com mais claridade da
imagem [19] (Figura 30).
Figura 30- Imagem a preto e branco indicando os pontos mais claros da imagem inicial
Pode acontecer obter-se uma imagem com vários pontos brancos que não correspondem
ao nosso centro e apenas representam pequenos pontos de claridade que não fazem parte
do nosso objetivo, por isso é aplicado um filtro á nossa imagem, de modo a eliminar
esses pontos espalhados, e obter-se assim o centro desejado.
Aplicou-se um filtro de erosão [20] , este filtro percorre todos os pixéis da imagem e em
cada pixel procura os valores dos pixéis vizinhos, e o valor do nosso pixel irá ficar com
o valor mais baixo dos pixéis vizinhos, ficando assim o nosso problema resolvido, uma
vez que o centro contém muitos mais pontos claros do que os pontos isolados.
Após estar encontrada a nossa área mais clara da imagem, vai-se calcular o centro dessa
imagem, e comparar o centro da mesma com o centro da câmara.
O nosso ponto “centro” vai ter duas coordenadas, a coordenada em y, e a coordenada
em x, “centroLargura” e “centroComprimento” respetivamente.
A nossa função “centroComprimento” recebe como parâmetros de entrada o array
contendo os índices dos pixéis mais claros, e a imagem recebida. Depois procura qual a
31
primeira e a ultima posição do array, que neste caso serão as posições no eixo “x”, é
calculado qual o pixel que está no centro. A variável “d” corresponde ao último pixel no
eixo “x”, e a variável “c” corresponde ao primeiro pixel no eixo ”x”. O índice do pixel
que será considerado o “centroComprimento” é calculado somando o índice do
primeiro pixel ao índice do último e dividindo por dois “(d+c)/2”.
Arrays.sort(array);
int c=array[0];
int d=array[array.length -1];
int centroComprimento=(int)(d+c)/2;
return centroComprimento;
32
Se o centro da nossa área mais clara não estiver no centro da imagem, é necessário
mover o Drone de modo a que o centro da imagem seja igual ao centro do nosso ponto
mais claro.
Devido á instabilidade do Drone quando pairava não foi possível definir como centro
apenas um pixel, pois se assim fosse muito dificilmente o nosso algoritmo funcionaria.
Por isso foi definido um conjunto de pixéis que foi considerado como sendo o centro.
Neste caso, o nosso centro vai ser um conjunto de 400 pixéis para a câmara inferior
(20x20).
Para o Drone aterrar era necessário que a condição de estar no centro se verificasse, ou
seja, era necessário que a condição em baixo devolvesse o valor true.
33
34
Capitulo 5
5 Navegação Autónoma
Neste capítulo vai ser abordado o controlo do Drone, explicando a biblioteca usada para
facilitar o controlo do Drone como também a aplicação desenvolvida.
O Drone foi desenvolvido para ser controlado por um dispositivo, podendo ser um
computador, iPhone, iPad, ou Andoid esse dispositivo liga-se ao Drone através de uma
rede wireless criada pelo próprio Drone como já foi explicado no capítulo 3.2. Depois
de estarem ligados o Drone entra num ciclo em que espera as instruções enviadas pelo
dispositivo, essas instruções são AT Commands, também já explicados no capítulo 3.3.
Esses comandos enviados vão-se traduzir no movimento do Drone, tarefas como a
descolagem, aterragem entre outras tornam-se fáceis porque o próprio Drone está
programado para as receber.
Para facilitar o trabalho dos programadores, estes usam algumas bibliotecas existentes
para controlar o Drone. As bibliotecas mais utilizadas são as seguintes:
35
ARDroneForP5
Esta biblioteca foi desenvolvida por uma vasta equipa de programadores na
Universidade de Tóquio, na área da Engenharia Aeroespacial Inteligente, tendo
como programador principal Shigeo Yoshida. Esta biblioteca está muito bem
estruturada e é de fácil compreensão e utilização, e contém uma API que explica
detalhadamente os métodos/ construtores que podem ser invocados aquando do
uso da mesma. Após alguns testes foi verificado que esta biblioteca continha um
erro que fazia com que o Drone após a descolagem não se conseguisse
estabilizar normalmente, o que levava a vários problemas, e impossibilitou a
continuação do uso da mesma para o nosso projeto [22].
JavaDrone
A JavaDrone foi desenvolvida por Codeminders, uma empresa de consultoria
fundada em Silicon Valley em 2004.Esta biblioteca permite o controlo do Drone
com o teclado do pc ou com um periférico externo (joystick) [23]. Para o correto
funcionamento desta biblioteca é necessário o uso de duas outras bibliotecas
para complementar a JavaDrone. São elas:
36
segundo parâmetro é mandado o valor da
definição escolhida anteriormente.
Define qual a camara que o Drone transmite,
necessita como parâmetro de entrada de um dos
void selectVideoChannel seguintes valores (HORIZONTAL_ONLY,
(ARDrone.VideoChannel); VERTICAL_ONLY,
VERTICAL_IN_HORIZONTAL,
HORIZONTAL_IN_VERTICAL)
void trim(); Calibra os sensores referentes a Pitch, Yaw e Roll
Adiciona o objeto Drone, a função toma o
void
conhecimento de todas as constantes incluídas no
addStatusChangeListener(ARDrone
objeto, como exemplo portas de comunicação,
drone);
endereço IP, etc.
Adiciona o objeto Drone, a função toma o
void addNavDataListener conhecimento de todas as constantes incluídas no
(ARDrone drone); objeto, como exemplo portas de comunicação,
endereço IP, etc.
int getBattery(); Retorna o valor da bateria
float getAltitude(); Retorna o valor da altitude
float getPitch(); Retorna o valor do Pitch
float getRoll(); Retorna o valor do Roll
float getYaw(); Retorna o valor do Yaw
37
5.2 Programa de Controlo Manual
Para alternar entre a câmara da frente e a câmara inferior é usado um dos botões que
está localizado no canto superior esquerdo, sendo usada a seguinte função:
//Câmara da frente
drone.selectVideoChannel(ARDrone.VideoChannel.HORIZONTAL_ONLY);
// Câmara de baixo
drone.selectVideoChannel(ARDrone.VideoChannel.VERTICAL_ONLY);
38
drone.trim();//envia comando “AT*FTRIM”
waiting(1);//aguarda um segundo para calibrar o Drone
drone.takeOff();//envia o comando para descolar
Os seguintes botões: Frente, Trás, Esquerda, Direita, Subir, Descer e Rodar são usados
para controlar o Drone. Todos eles funcionam através da função move();, que
dependendo dos parâmetros inseridos é executa diferentes ações no Drone. Esse
parâmetro é uma variável que pode ser alterada no ambiente gráfico, dando assim a
possibilidade de o utilizador alterar a velocidade a que o Drone se move. Alguns
exemplos das ações executadas com os diferentes parâmetros são os seguintes:
Quando é para aterrar o Drone faz uso do sonar, sensor que lhe fornece a informação da
altura, para que ele possa ir diminuindo a altura e faça uma aterragem suave, é invocada
a seguinte função:
39
Figura 33- Interação entre processamento de imagem e algoritmo de navegação
No âmbito da navegação autónoma com a câmara frontal foi inserido um botão Segue
folha no ambiente gráfico que ao ser pressionado dá início ao algoritmo implementado.
(Figura 34)
40
Figura 34- Algoritmo usado na navegação autónoma com a câmara frontal
if(video.getvalorfrente()==1)
{
System.out.println("Mover para a esquerda"+soma);
jTextArea1.append("\tMover para a esquerda"+soma);
drone.move(-vel,0,0,0);
Thread.sleep(500);
soma++;
}
Quando o valor recebido é 2 o Drone move-se para a direita, sendo invocado o seguinte
código:
41
if(video.getvalorfrente()==2)
{
System.out.println("Mover para a direita"+soma);
jTextArea1.append("\t Mover para a direita"+soma+"\n");
drone.move(vel,0,0,0);
Thread.sleep(500);
soma++;
}
Quando o valor recebido é 3 o Drone move-se para cima sendo invocado o seguinte
código:
if(video.getvalorfrente()==3)
{
System.out.println("Mover para a cima"+soma);
jTextArea1.append("\t \tMover para a cima"+soma+"\n");
drone.move(0,0,velx,0);
Thread.sleep(500);
soma++;
}
Quando retorna o valor 4 o Drone move-se para baixo sendo invocado o seguinte
código:
if(video.getvalorfrente()==4)
{
System.out.println("+++++Mover para a baixo++++"+soma);
jTextArea1.append("\t \t Mover para a baixo"+soma+"\n");
drone.move(0,0,-velx,0);
Thread.sleep(500);
soma++;
}
Com esta abordagem foi conseguido colocar o Drone a mover se tanto no sentido
vertical como horizontal, fazendo assim com que o Drone navegasse autonomamente
com a câmara da frente.
42
Figura 35- Algoritmo usado na navegação autónoma com a câmara de baixo
Logger.getLogger(Controlautonomo.class.getName()).log(Level.SEVERE,
null, ex);
}
findpoint();
}
else if(image!=1)
{
try {
Thread.sleep(1700);
} catch (InterruptedException ex) {
Logger.getLogger(Controlautonomo.class.getName()).log(Level.SEVERE,
null, ex);
}
43
procuraponto();
}
}
}
});
thread.setName("Aterra centro");
thread.start();
}
Essa função cria um ciclo que poderá tomar duas opções, a primeira que é chamada caso
não encontre a folha chama a função procuraponto() que invoca o seguinte código:
Essa função envia para o Drone o comando de mover para a frente e segue-se isto
repetidamente até a função getimage(), devolver o valor inteiro 1. A função getimage()
retorna 1 quando a folha aparecer no raio da imagem capturada pela câmara inferior e
assim o ciclo deixa de invocar a função procuraponto(), e passa ao segundo caso onde
invoca a função aterracentro(). A função aterracentro() tem uma variável que define a
velocidade que o Drone se irá mover depois, de seguida dependendo do que a função
getvalorbaixo() retornar irá enviar a ação para o Drone. A função getvalorbaixo()
poderá retornar valores inteiros entre 1 e 5, em que o valor 1 indica que a folha se
encontra do lado esquerdo do Drone, logo ele tem que se mover para esquerda e invoca
o seguinte código:
if(video.getvalorbaixo()==1)
{
System.out.println("Mover para a esquerda");
jTextArea1.append("\t \tMover para a esquerda \n");
drone.move(-velx,0,0,0);
}
O valor 2 indica que a folha se encontra do lado direito do Drone, logo ele tem de se
mover para a direita e invoca o seguinte código:
if(video.getvalorbaixo()==2)
{
44
System.out.println("+++++Mover para a direita++++");
jTextArea1.append("\t \tMover para a direita \n");
drone.move(velx,0,0,0);
}
O valor 3 indica que a folha se encontra a frente do Drone, logo tem de se mover para a
frente e invoca o seguinte código:
if(video.getvalorbaixo()==3)
{
System.out.println("++++++Mover para frente++++");
jTextArea1.append("\t \tMover para a frente \n");
drone.move(0,-velx,0,0);
}
O valor 4 indica que a folha se encontra a trás do Drone logo tem de se mover para trás
e invoca o seguinte código:
if(video.getvalorbaixo()==4)
{
System.out.println("+++++Mover para tras++++");
jTextArea1.append("\t \tMover para a tras \n");
drone.move(0,velx,0,0);
}
Todos estes exemplos estão ilustrados na figura que se segue (Figura 36)
Quando a função devolve o valor 5 indica que a folha está posicionada no centro logo o
Drone poderá aterrar, é invocado o seguinte código:
45
if(video.getvalorbaixo()==5){
System.out.println(" PODE ATERRAR ");
jTextArea1.append("\t \t PODE ATERRAR PODE ATERRAR \n");
drone.land();
running=false;
}
46
47
Capitulo 6
6 Testes Experimentais
Neste capítulo serão apresentados todos os testes que foram realizados ao longo do
desenvolvimento do projeto, nomeadamente testes com a plataforma Android, e com o
computador. Serão apresentados os resultados obtidos da navegação do Drone com um
dispositivo móvel com sistema operativo Android, e serão apresentados também os
resultados obtidos com a execução de ações de navegação e com a navegação autónoma
utilizando o computador.
Com um programa específico obteve-se o controlo quase total do Drone, usando apenas
o ecrã do telemóvel, e a nossa imaginação.
48
Figura 38-Painel inicial para controlo do Drone em Android
Com esta aplicação foi possível configurar alguns parâmetros, tais como a altitude
máxima a que o Drone iria pairar (Figura 39), a velocidade máxima dos seus
movimentos, a sensibilidade do Joystick, entre outros. (Figura 40)
49
Este teste serviu como primeiro contato com a plataforma móvel e as suas
funcionalidades.
Numa fase inicial o pretendido era conhecer o Drone. Ver como se deslocava, como
reagia aos comandos enviados, e tirar o máximo de conhecimentos acerca da interação
com o Drone eram os principais objetivos. Foi criado um controlo simples, e usando os
botões do ambiente gráfico foi possível mover o Drone para a direita, esquerda, cima e
baixo, rodá-lo sobre si mesmo e até alternar entre as suas duas câmaras.
Como o objetivo do projeto era desenvolver uma aplicação que permita a navegação
autónoma do Drone, depois de já ser possível mover o Drone consoante a nossa
vontade, passou-se para a fase seguinte do projeto, que teve como principal objetivo
mover o Drone de um ponto inicial até um ponto final, dando apenas a informação
relativa aos segundos que ele iria andar na direção pretendida e a que velocidade o iria
fazer.
Procedeu-se á criação do ambiente gráfico onde foi possível criar uma interface intuitiva
e clara para o utilizador controlar o Drone podendo definir a velocidade em que o Drone
se desloca como visualizar o vídeo enviado pelas camaras e os valores dos sensores
(Figura 41).
50
Com a conclusão deste teste conseguiu-se perceber o potencial da biblioteca e o quanto
nos facilitará no decorrer deste projeto, foi possível controlar o Drone conseguindo
movê-lo em todas as direções desejadas, obteve-se os dados dos sensores e do vídeo
transmitido pelas câmaras, como também foram realizadas com sucesso várias
trajetórias pré-definidas, tendo observado que a estabilidade do Drone não era a
desejada.
O Drone move-se pela área de teste até encontrar a folha, e depois de a ter localizado,
ele passa a mover-se de modo a ficar posicionado mesmo por cima do centro da mesma,
para depois aterrar, tal como se pode verificar na Figura 42.
51
Enquanto o Drone não se posiciona no centro da folha, ele move-se para a esquerda,
(Figura 43) ou direita, ou frente ou trás até que esta condição seja verificada.
Este ficheiro de texto pode depois ser aberto em Matlab para comprovar que o erro
diminui até perto do valor 0, que é o momento em que o Drone recebe o comando para
aterrar, como exemplificado na Figura 44.
O valor do erro foi calculado usando o teorema de Pitágoras, usando a equação (2).
(2)
52
Figura 44- Gráfico do erro desde que deteta folha até aterrar
53
Figura 45- Como é calculado o "erro"
No final deste teste foi possível comprovar a eficácia do algoritmo usado. No entanto,
devido á instabilidade do Drone enquanto pairava, a partir do momento em que devido a
essa instabilidade ele perdia a folha do raio de visão da câmara, saía do algoritmo
previsto e caso não voltasse a ver a folha, permanecia a pairar até lhe ser enviado o
comando para aterrar. Não foi possível resolver este problema devido á falta de sensores
nas extremidades laterais do Drone, que nos informariam da existência de algum
obstáculo, sem essa informação qualquer obstáculo não planeado levaria á queda do
Drone podendo levar a estragos materiais.
54
Figura 46- Exemplo de funcionamento da navegação com a câmara frontal
No final deste teste foi possível comprovar a eficácia do algoritmo, conseguindo mover
o Drone autonomamente através da imagem enviada pela câmara da frente, mas como
no teste anterior verificou-se também uma certa instabilidade no Drone, essa
instabilidade pode ter várias razões, podendo ser devido a algum motor que não esteja
devidamente calibrado, ou a alguma hélice que esteja ligeiramente danificada o que
torna a resolução desse problema muito difícil.
55
Capitulo 7
7 Conclusões
Neste capítulo irá ser feita uma análise critica ao projeto desenvolvido, falando sobre os
resultados obtidos e sobre os que não foram concretizados.
Este projeto resultou numa grande aprendizagem por parte do grupo. Foram estudadas
tecnologias que nunca tinham sido estudadas por nós como por exemplo técnicas de
imagem, e a comunicação por sockets entre um robô e um computador.
56
7.2 Limitações e Trabalho Futuro
No decorrer do projeto foram encontrados alguns problemas que podiam ser corrigidos
na plataforma em que foi desenvolvido o projeto.
Como principais motivos que nos trouxeram mais dificuldades e que poderiam ser
resolvidos, o problema da bateria do Drone durar apenas cerca de dez minutos, o que
para quem está em testes torna-se cansativo estar repetitivamente estar a carregar a
bateria.
Outro dos problemas é o facto de o Drone apenas ter um mecanismo de emergência
total, ou seja, apenas há uma maneira de cortar a alimentação ao robô, o que mais uma
vez para quem se encontra em testes experimentais se torna um grande obstáculo, pois
com um robô voador não é possível possuir um controlo 100% fiável do mesmo, o que
pode levar a estragos materiais, caso o robô tenha algum erro durante os testes que
algumas vezes envolvem erros de programação.Com um botão na parte exterior da
carcaça, este problema seria minimizado, pois em casos onde é mesmo preciso fazer o
reset do Drone seria bastante útil.
Tem-se a referir que como a comunicação é feita via wireless, por vezes há perda de
dados e mesmo da comunicação, principalmente em ambientes com um número elevado
de redes wireless disponíveis.
Para trabalho a desenvolver futuramente seria a integração de uma câmara Kinect com o
Drone, o que iria resolver o problema da profundidade e consequentemente a deteção de
obstáculos.
57
Referências Bibliográficas
[1] “eps,” [Online]. Available: http://www.eps.ufsc.br/disserta99/vieira/cap2.html. [Acedido
em Setembro 2013].
58
http://pt.wikipedia.org/wiki/Vis%C3%A3o_computacional. [Acedido em 2013 Fevereiro].
59