navegação autónoma em robôs aéreosprojinf.estig.ipb.pt/~a23265a23503/relatorio.pdf ·...
TRANSCRIPT
Navegação Autónoma em Robôs Aéreos
Filipe André Nogueira Coelho Nº23503
Jorge Fernando Magalhães Santos Nº23265
Trabalho realizado sob a orientação de:
Professor Paulo Jorge Pinto Leitão
Professor José Luís Sousa de Magalhães Lima
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
Filipe Coelho, Jorge Santos
Setembro 2013
A Escola Superior de Tecnologia e Gestão não se responsabiliza pelas opiniões expressas
neste relatório.
Certifico que li este relatório e que na minha opinião, é adequado no seu conteúdo e forma
como demonstrador do trabalho desenvolvido no âmbito da UC de Projeto.
___________________________________________
Paulo Leitão Orientador
Certifico que li este relatório e que na minha opinião, é adequado no seu
conteúdo e forma como demonstrador do trabalho desenvolvido no
âmbito da UC de Projeto.
___________________________________________
José Lima Coorientador
Certifico que li este relatório e que na minha opinião, é adequado no seu
conteúdo e forma como demonstrador do trabalho desenvolvido no
âmbito da UC de Projeto.
___________________________________________
Arguente
Aceite para avaliação da UC de Projeto
Agradecimentos
Queremos agradecer ao nosso orientador, Professor Paulo Leitão e ao coorientador Professor
José Lima pelo incansável apoio que nos deram durante o decorrer do nosso projeto
.Queremos agradecer também às nossas famílias, pois sem o apoio e compreensão delas
tinha sido impossível concluirmos este projeto. Queremos agradecer também a todos os
nossos colegas que estiveram sempre dispostos a dar-nos a ajuda, apoio e as palavras de
consolo que fomos precisando no decorrer do nosso percurso académico. Queremos
agradecer ao Instituto Politécnico de Bragança, nomeadamente a Escola Superior de
Tecnologia e Gestão de Bragança, pelas condições que nos ofereceu no desenvolvimento do
projeto.
Resumo
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.
No sistema de navegação foi construído um algoritmo que permitiu o deslocamento autónomo
do Drone.
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.
A elaboração do nosso projeto envolveu conceitos de redes, processamento de imagem,
programação orientada a objetos e matemática.
Palavras-chave:
ARDrone, Java, Navegação Autónoma, Processamento de Imagem, Robôs Aéreos,
Quadricópteros.
Abstract
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:
ARDrone, Java, Autonomous driving, Image Processing, Aerial Robots, Quadcopter
Conteúdo
1 Introdução ......................................................................................................................... 2
1.1 Contextualização ..................................................................................................................... 2
1.2 Motivação e Objetivos ............................................................................................................. 3
1.3 Organização do Documento .................................................................................................... 4
2 Navegação Autónoma em Robôs Aéreos ......................................................................... 6
2.1 Robótica Móvel ....................................................................................................................... 6
2.2 Robôs Aéreos ........................................................................................................................ 12
2.3 Navegação autónoma ............................................................................................................ 14
3 Descrição do Caso de Estudo ......................................................................................... 17
3.1 Estrutura dos Quadricópteros ................................................................................................ 17
3.2 Descrição do AR.Drone ........................................................................................................ 20
3.3 Protocolos de Comunicação .................................................................................................. 23
3.4 Comunicação Entre o ARDrone e o Dispositivo Móvel ....................................................... 24
4 Aquisição e Processamento de Imagem ........................................................................ 27
4.1 Visão Artificial ...................................................................................................................... 27
4.2 Algoritmo de Processamento de Imagem .............................................................................. 27
4.2.1 Aquisição da Imagem .................................................................................................... 28
4.2.2 Processamento da Imagem ............................................................................................ 29
5 Navegação Autónoma ..................................................................................................... 35
5.1 Controlo do Drone ................................................................................................................. 35
5.2 Programa de Controlo Manual .............................................................................................. 38
5.3 Navegação Autónoma do Drone ........................................................................................... 39
5.3.1 Navegação Autónoma com a Câmara Frontal ............................................................... 40
5.3.2 Navegação Autónoma com a Câmara Inferior .............................................................. 42
6 Testes Experimentais ...................................................................................................... 48
6.1 Navegação do AR.Drone usando um Dispositivo com Android ........................................... 48
xiv
6.2 Navegação semiautónoma do Drone ..................................................................................... 50
6.3 Navegação Autónoma Utilizando a Imagem da Câmara Inferior ......................................... 51
6.4 Navegação Autónoma Utilizando a Imagem da Câmara Frontal .......................................... 54
7 Conclusões ....................................................................................................................... 56
7.1 Objetivos Concretizados ........................................................................................................ 56
7.2 Limitações e Trabalho Futuro ............................................................................................... 57
xvi
Lista de Tabelas
Tabela 1- Comparativo entre AR.Drone 1.0 e AR.Drone 2.0 ............................................................... 23
Tabela 2- AT Commands e respetivas descrições ................................................................................. 23
Tabela 3- Funções de Configuração da Biblioteca JavaDrone .............................................................. 36
Tabela 4- Funções de movimento da biblioteca JavaDrone .................................................................. 37
xvii
xviii
Lista de Figuras
Figura 1- Rocky 4 .................................................................................................................................... 3
Figura 2-Robô Móvel [3] ........................................................................................................................ 6
Figura 3- Tipos de Robôs ........................................................................................................................ 8
Figura 4-Robô aéreo usado como plataforma aérea para câmaras [4]..................................................... 8
Figura 5- Aeryon SkyRanger™ [5] ........................................................................................................ 9
Figura 6-- Robô terrestre usado pela NASA para obter amostras do solo de Marte [6] .......................... 9
Figura 7- Twendy-One [26] .................................................................................................................. 10
Figura 8- Robonaut 2 [8] ....................................................................................................................... 10
Figura 9- Kit completo do SuperGNOM Pro ........................................................................................ 11
Figura 10-Kingfish [10]......................................................................................................................... 11
Figura 11-DraganFlyer X4-ES UltraPortable ........................................................................................ 13
Figura 12-Elbit Systems Hermes 450 .................................................................................................... 13
Figura 13- MQ-1 Predator ..................................................................................................................... 14
Figura 14-Exemplo de um algoritmo de navegação autónoma ............................................................. 15
Figura 15-Movimento das hélices do Drone ......................................................................................... 17
Figura 16- Forças que atuam sobre o Drone ......................................................................................... 18
Figura 17- O movimento Hover ............................................................................................................ 18
Figura 18- O movimento Roll ............................................................................................................... 19
Figura 19- O movimento Pich ............................................................................................................... 19
Figura 20- O movimento Yaw ............................................................................................................... 19
Figura 21- Exemplo do movimento do throttle ..................................................................................... 20
Figura 22-Identificadores para reconhecimento .................................................................................... 21
Figura 23-Placa principal do Drone ...................................................................................................... 21
Figura 24-Sensor Ultrassom do Drone .................................................................................................. 22
Figura 25- Modo indoor e outdoor do Drone ........................................................................................ 22
Figura 26- Algoritmo usado no processamento da imagem .................................................................. 28
Figura 27- Divisão da imagem em grupos de blocos ............................................................................ 29
Figura 28- Divisão do grupo de blocos em macro blocos ..................................................................... 29
Figura 29- Conversão da Imagem para cinzento ................................................................................... 30
Figura 30- Imagem a preto e branco indicando os pontos mais claros da imagem inicial .................... 31
Figura 31- Centro da câmara e centro da área mais clara da Imagem ................................................... 32
Figura 32- Ambiente Gráfico para Controlo Manual ............................................................................ 38
Figura 33- Interação entre processamento de imagem e algoritmo de navegação ................................ 40
Figura 34- Algoritmo usado na navegação autónoma com a câmara frontal ........................................ 41
Figura 35- Algoritmo usado na navegação autónoma com a câmara de baixo ..................................... 43
Figura 36- Exemplo prático ................................................................................................................... 45
Figura 37- Exemplo de folha no centro ................................................................................................. 46
Figura 38-Painel inicial para controlo do Drone em Android ............................................................... 49
xix
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
1
2
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
A robótica é uma área científica multidisciplinar com um basto interesse em torno da
qual outras áreas têm tido desenvolvimentos significantes, e por esse motivo nos
últimos anos tem-se observado um enorme crescimento dos sistemas robóticos nas mais
diversas áreas. Por outro lado, o seu caracter interdisciplinar e a complexidade dos
problemas existentes, faz com que dependa da constante evolução dos sensores e
atuadores, ou das ferramentas matemáticas, o que de certa maneira dificulta o seu
avanço.
Numa fase inicial do seu crescimento notou-se um grande desenvolvimento na robótica
industrial, principalmente com a utilização de robôs manipuladores. Estes robôs
realizam tarefas na área da indústria da pintura, da soldagem e automóvel. Normalmente
são usados em tarefas repetitivas ou perigosas para o homem.
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
3
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
1.2 Motivação e Objetivos
O principal objetivo deste projeto consiste em desenvolver um sistema de navegação
autónoma para um robô aéreo, neste caso um quadricóptero, e que permita o seu
deslocamento autónomo. Para isso existem duas possibilidades, a primeira é construir
um robô aéreo, que devido à sua complexidade seria uma tarefa extremamente difícil, a
segunda é utilizar um robô aéreo que já se encontre no mercado, onde tanto a sua
construção como a programação interna já foram realizadas, tarefas como a descolagem,
aterragem entre outras são conhecidas e podem ser usadas facilmente. No âmbito deste
projeto foi usada a segunda opção integrando a imagem recebida pelas camaras do robô
aéreo ARDrone, que está disponível no Laboratório de Controlo, Automação e Robótica
4
(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.
, O sistema de navegação autónoma irá ser desenvolvido utilizando algumas bibliotecas
existentes, assim como o processamento das imagens fornecidas pelas duas câmaras do
Drone (uma localizada na parte frontal e outra na parte inferior, tal como será
detalhadamente descrito capitulo 3).
1.3 Organização do Documento
A estrutura deste documento é a seguinte: o primeiro capítulo apresenta a
contextualização do presente projeto, as motivações e os objetivos do trabalho. O
segundo capítulo descreve a robótica móvel em geral, e mais incisivamente sobre a
robótica móvel aérea, explicando em que consiste e dando exemplos de robôs aéreos,
sendo também abordado também o tema da navegação autónoma em robôs móveis. O
terceiro capítulo aborda a estrutura dos quadricópteros em geral, e mais detalhadamente
do nosso caso de estudo, apresentando uma pequena descrição do mesmo, onde são
descritas as suas características, os seus sensores, e os protocolos usados na
comunicação entre o robô e os dispositivos móveis ligados a ele, como por exemplo um
smartphone com um sistema operativo Android ou iOs. O quarto capítulo explica como
é realizada a aquisição da imagem, descrevendo os algoritmos usados, e o
processamento da mesma, incluindo também a interface com o módulo de navegação. O
quinto capítulo aborda a navegação autónoma do Drone, explicando os métodos usados
para realizar o seu movimento autónomo, explica o controlo e estrutura dos
quadricópteros, nas bibliotecas utilizadas no nosso projeto, quais os movimentos que o
Drone executa, e explica também sobre o movimento autónomo do Drone após a
ligação entre o processamento de imagem e a navegação autónoma. O sexto capítulo
apresenta os testes experimentais realizados. No sétimo e último capítulo são
apresentadas as conclusões relativas ao nosso trabalho, e as limitações que foram
encontradas no desenvolvimento do mesmo.
5
6
Capitulo 2
2 Navegação Autónoma em Robôs Aéreos
Neste capítulo será abordado o tema da navegação autónoma em robôs móveis, dando
vários exemplos e explicando os problemas encontrados quando é necessário desenhar
uma aplicação de navegação autónoma para um robô móvel.
2.1 Robótica Móvel
Um robô móvel é um dispositivo automático, que é capaz de se movimentar e interagir
num ambiente definido [2] , tal como ilustrado na Figura 2. A grande diferença destes
robôs para os robôs de base fixa é a sua base, que no caso dos móveis permite a sua
locomoção para outros espaços.
Figura 2-Robô Móvel [3]
Quando se constrói um robô móvel encontra-se pela frente um grande número de
desafios, tais como erros de orientação, problemas da má leitura dos sensores, erros de
7
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:
Navegação: É preciso encontrar uma forma de representar o ambiente que rodeia
o robô. Esta representação deve ser a mais detalhada possível, de modo a que
erros de navegação do robô relacionados com os sensores consigam ser quase
insignificantes. A parte de decisão do robô deve ser construída de modo a que o
desempenho seja o melhor possível.
Reconhecimento: É vital que o robô consiga reconhecer o ambiente no qual está
inserido. Para isto é necessário que o processamento de dados e de imagens
esteja a ser feito da maneira mais rápida e correta possível. Problemas como a
luminosidade excessiva ou até mesmo de ruídos podem vir a afetar os sensores.
Cooperação: Nos dias de hoje existe a necessidade de haver vários robôs a
trabalhar em conjunto para desempenhar uma determinada tarefa. É
determinante para o sucesso da mesma que os robôs tenham algum tipo de
comunicação entre eles, pois por exemplo no caso de ocorrer algum imprevisto,
parem todas as suas funções.
Localização: A interpretação da informação sensorial para localizar um robô no
seu ambiente, é uma das principais características para dotar um robô de
capacidades autónomas. A localização pode ser feita através de medições
relativas ou de medições absolutas. Os sensores usados para efetuar medições
relativas (giroscópios, acelerómetros), têm uma boa precisão a curto prazo,
porém o cálculo da posição leva á acumulação de erros de posição e orientação.
Por outro lado os sensores usados para efetuar medições absolutas (ultrassons,
GPS) permitem estimar a posição global com um erro limitado, no entanto em
determinadas condições os erros podem ser consideravelmente maiores.
Definição de trajetórias: Ao planear uma trajetória, é impossível saber-se á priori
com exatidão todos os conhecimentos sobre o ambiente, em alguns casos a
geometria do espaço é conhecida apenas parcialmente, e quanto mais incompleto
o modelo do ambiente, mais limitado estará o planeamento da trajetória.
8
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)
Figura 3- Tipos de Robôs
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]
9
Na Figura 5 apresenta um exemplo de um robô que faz a patrulha e monitorização de
fronteiras.
Figura 5- Aeryon SkyRanger™ [5]
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]
10
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.
Figura 8- Robonaut 2 [8]
Figura 7- Twendy-One [26]
11
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.
Figura 9- Kit completo do SuperGNOM Pro
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]
.
Figura 10-Kingfish [10]
12
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:
Patrulhamento e monitorização de regiões remotas ou fronteiras.
Reconhecimento tácito e apoio operacional em missões e atividades militares.
Segurança e apoio policial.
Mapeamento de regiões.
Pesquisa ambiental e do clima, incluindo composição atmosférica e qualidade do
ar.
Deteção de incêndios e suporte á sua extinção.
Existem no mercado algumas aeronaves deste tipo a serem comercializadas, o
DraganFlyer X4-ES Ultra Portable (Figura 11) é um desses exemplos, sendo um
quadricóptero fabricado pela empresa Draganfly Innovations Inc, que foi fundada em
1988 por Zenon e Christine Dragan. Este robô tem como aplicações a segurança pública
ou a fotografia, [11] a Draganfly Innovations já vendeu mais de 8000 destes UAV’s e
estão a ser usados pela polícia e forças polícias de busca e salvamento nos mais
diferentes países, como por exemplo, Canadá, Austrália, Hong Kong, sendo mesmo um
13
dos primeiros UAVs usados para salvar vidas. Este robô é todo construído em fibra de
carbono.
Figura 11-DraganFlyer X4-ES UltraPortable
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]
Figura 12-Elbit Systems Hermes 450
14
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]
Figura 13- MQ-1 Predator
2.3 Navegação autónoma
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).
15
Figura 14-Exemplo de um algoritmo de navegação autónoma
Neste trabalho, será focada a navegação autónoma de um robô aéreo, nomeadamente o
ARDrone que será descrito no capítulo que se segue.
16
17
Capitulo 3
3 Descrição do Caso de Estudo
Neste capítulo será analisada a estrutura do robô aéreo de asas fixas, mais conhecido
como quadricóptero. Irá ser apresentado o quadricóptero de nome ARDrone,
apresentando com detalhe a sua descrição, os protocolos de comunicação e de que
forma é feita a comunicação com o dispositivo.
3.1 Estrutura dos Quadricópteros
Um quadricóptero contém quatro motores que estão suportados numa estrutura
mecânica. Normalmente esses motores trabalham em pares opostos, ou seja o motor um
trabalha em conjunto com o motor três para que o Drone se desloque numa direção,
enquanto que o motor dois e o motor quatro trabalham em conjunto para a direção
oposta (Figura 15). Estes motores geram as forças de pitch, roll e yaw que estão a atuar
no Drone (Figura 16).
Figura 15-Movimento das hélices do Drone
18
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.
Se todos os motores se movimentarem na mesma velocidade angular não vai existir
nenhuma força no eixo de rotação, no entanto se a velocidade angular de cada motor par
for alterada já vai existir uma força que vai traduzir em aceleração angular em torno do
eixo de rotação.
O movimento na vertical é criado através do aumento ou diminuição da pressão dos
motores, e o movimento horizontal é criado através de diferentes acelerações angulares.
O Drone possui 5 movimentos básicos: Hover, Roll, Pitch, Yaw, Throttle
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.
Figura 17- O movimento Hover
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).
19
Figura 18- O movimento Roll
O movimento Pitch é similar ao Roll, no entanto, ao alterar o par de hélices às quais
atribui-se os valores contrários fazendo com que ele se movimente para a frente ou para
trás (Figura 19).
Figura 19- O movimento Pich
Este movimento é conseguido através da variação da velocidade das quatro hélices.
Dando velocidades positivas às hélices esquerda e direita, e dando velocidades
negativas às hélices da frente e trás. Este movimento faz com que o Drone gire sobre si
próprio (Figura 20).
Figura 20- O movimento Yaw
20
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).
Figura 21- Exemplo do movimento do throttle
3.2 Descrição do AR.Drone
Neste trabalho utilizou-se o robô aéreo ARDrone, produzido pela empresa francesa
Parrot desde 2010, que é um dos mais populares quadricópteros do momento. Com este
dispositivo surgiu um conceito inovador, uma plataforma móvel controlada pelo touch
screen de um iPhone, iPad, ou Andoid, através da rede wireless, com um controlo
simples e intuitivo.
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.
21
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.
Figura 23-Placa principal do Drone
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
22
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.
Figura 24-Sensor Ultrassom do Drone
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.
Figura 25- Modo indoor e outdoor do Drone
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.
23
Tabela 1- Comparativo entre AR.Drone 1.0 e AR.Drone 2.0
Característica Ar Drone 1.0 Ar Drone 2.0
Câmara vertical e
horizontal VGA 720p HD
Acelerómetro 3 eixos 3 eixos
Giroscópio 2 eixos / 1 eixo yaw 3 eixos
Sensor de pressão Não Sim
Ultra-som Sim Sim
Magnetómetro Não 3 eixos
Controlo absoluto Não Sim
Kernel Linux 2.6.27 2.6.32
Processador ARM9 32b 468 MHz 1GHz 32b ARM Cortex
A8
RAM 128MB 1GB
WiFi B/g B/g/n
3.3 Protocolos de Comunicação
Os AT Commands são conjuntos de texto enviados para o Drone para controlar as suas
ações, são codificados como conjuntos de caracteres ASCII de 8 bits, em que o </r>
indica o fim do mesmo, se o comprimento do comando ultrapassar os 1024 caracteres
ou estiver incorreto será rejeitado pelo Drone. Todos os comandos têm a mesma
formatação começando por “AT”, seguido do nome do comando, um sinal de igual (=),
o número da sequência, número este que deve começar sempre em 1 e ir incrementando
consoante o número de comandos enviados, e no final, é acrescentado o argumento
relativo ao movimento que é preciso realizar com o Drone, alguns desses exemplos
estão descritos na Tabela 2:
Tabela 2- AT Commands e respetivas descrições
AT command Argumentos Descrição
AT * REF sequência, argumento Descolagem / Aterragem /
Paragem de emergência
AT * PCMD sequência, roll, pitch, gaz,
yaw Move o Drone
AT * FTRIM sequência Define a referência para o
plano horizontal
AT * CONFIG sequência, argumento Configuração do Drone
AT * COMWDG sequência Repor a comunicação com
Drone
24
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.
Os comandos AT* FTRIM e AT* COMWDG não necessitam de argumentos,
unicamente necessitam do valor da sequência para ser um comando valido e ser aceite
pelo Drone, são de extrema importância. O comando AT * FTRIM define a referência
para o plano horizontal, isto é, calibra os sensores internos dizendo que está num plano
horizontal, se este comando não for, enviado antes da descolagem dificilmente o Drone
conseguirá estabilizar, possibilitando violentos acidentes. O comando AT * COMWDG
é usado para repor a ligação com o Drone.
3.4 Comunicação Entre o ARDrone e o Dispositivo Móvel
O Drone pode conectar com uma larga variedade de dispositivos, esses dispositivos só
necessitam de comunicar via wireless e de ter um software para simplificar a interação
entre o Drone e a pessoa que o está a controlar, podendo ser um computador, Tablet ou
um smartphone. A ligação entre os dois dispositivos é feita através de uma rede wireless
25
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:
A porta UDP 5556 é a porta que recebe os AT commands, mais propriamente
todos os comandos que controlam o movimento do Drone.
A porta UDP 5554 é a porta por onde o Drone envia informações relativas ao
seu estado, nomeadamente, velocidade, posição, nível de bateria.
A porta UDP 5555 é a porta por onde a stream de vídeo é enviado.
Uma quarta porta chamada de porta de controlo, pode ser ligada através da porta
TCP 5559. Esta porta serve essencialmente para transferir dados críticos, e usada
para recuperar dados de configuração.
26
27
Capitulo 4
4 Aquisição e Processamento de Imagem
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.
4.1 Visão Artificial
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.
A receção e o processamento da imagem recebida pelos robôs móveis têm sido um
grande desafio para os investigadores na área da visão artificial.
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].
4.2 Algoritmo de Processamento de Imagem
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).
28
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.
4.2.1 Aquisição da Imagem
A aquisição de imagem pelas câmaras do Drone usa um formato de vídeo proprietário,
baseado numa versão simplificada do H.263 UVLC (Universal Variable Length Code)
[16].
A imagem é recebida em grupos de blocos correspondentes á altura da imagem (Figura
27), e cada bloco é dividido em macro blocos (Figura 28).
29
Figura 27- Divisão da imagem em grupos de blocos
Figura 28- Divisão do grupo de blocos em macro blocos
Cada macro bloco contém informação da imagem no formato Y CBCR, do tipo 4:2.0
4.2.2 Processamento da Imagem
Depois de conseguido o acesso á imagem recebida e às suas propriedades foi possível
começar a fazer o seu processamento. Neste caso em concreto a imagem recebida é
transformada numa imagem em tons de cinzento (Figura 29) pois assim torna-se mais
fácil o seu processamento pois tem-se apenas uma matriz de valores por pixel, enquanto
em Red Green Blue era necessário percorrer três matrizes por cada pixel. Nesta função
todos os pixéis são analisados e através dos valores de Red, Green Blue é calculado o
valor correspondente em cinzento. Esse valor é obtido multiplicando os mesmos valores
de RGB por determinados valores [17], e somando os três valores obtidos (1).
(1)
30
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.
A fim de se ter um processamento mais rápido, coloca-se a matriz num array, e
organizam-se os valores por ordem crescente, os nossos valores pretendidos estarão nas
últimas posições do array [18]. Na função baixo é feita a conversão da imagem para um
array.
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()];
31
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
32
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;
A mesma abordagem é tida para calcular o valor de “centroLargura”.
Neste ponto são conhecidos os índices dos pixéis que estão no centro da nossa imagem.
O valor A representa o que é definido como centro da câmara e o valor B representa o
que é definido como centro da área mais clara da imagem ( Figura 31)
Figura 31- Centro da câmara e centro da área mais clara da Imagem
Depois de serem conhecidos os valores de “centroLargura” e “centroComprimento”,
comparam-se estes valores com o “centroLargura” e “centroComprimento” da câmara,
que são dados pelas seguintes funções:
int centroImagemComprimento = im.getWidth() / 2;
int centroImagemLargura = im.getHeight() / 2;
onde as funções getWidth() e getHeight(), devolvem o comprimento e largura da
imagem recebida pela câmara.
33
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.
If(diferencaAoCentroComprimento <20 && diferencaAoCentroLargura <20)
O valor de “diferencaAoCentroComprimento é calculado subtraindo o valor devolvido
pela função “centroComprimento” ao valor devolvido pela função
“centroImagemComprimento”, e o valor de “diferencaAoCentroLargura” é calculado
subtraindo o valor devolvido pela função “centroLargura” ao valor devolvido pela
função “centroImagemLargura”.
Int diferencaAoCentroComprimento = centroImagemComprimento -
centroComprimento;
int diferencaAoCentroLargura = centroImagemLargura - centroLargura;
Se se verificarem estas condições, é enviada a respetiva informação para o módulo de
navegação autónoma que irá processar a informação e dar o comando para que o Drone
aterre.
34
35
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.
5.1 Controlo do Drone
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:
AR.Drone Software Development Kit
Esta biblioteca criada pela Parrot foi desenvolvida em C++, e tem alguns
exemplos e documentação. Explica de forma detalhada como usar a biblioteca,
no entanto os exemplos do código fonte eram apenas para iphone, e para o nosso
objetivo não era relevante. Como também está desenvolvida em C++ e tem
inúmeros ficheiros de código indocumentados o que tornava a sua compreensão
bastante difícil [21].
36
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:
Hidapi-1.1- Facilita a comunicação do programa com um periférico externo,
e fornece uma interface limpa e consistente para cada plataforma.
Log4j-1.2.17- Permite fazer o debug do código sem interferir na sua
execução. Com esta abordagem é possível descobrir rapidamente erros de
programação que sejam encontrados no programa.
Esta biblioteca traz já definidas algumas funções que tornam o processo de
desenvolvimento mais simples. Estas funções estão explicadas na tabela em
baixo.
As funções de configuração e de ligação ao Drone estão presentes na Tabela 3- Funções de
Configuração da Biblioteca JavaDroneTabela 3:
Tabela 3- Funções de Configuração da Biblioteca JavaDrone
void connect(); Inicia a ligação com o Drone
void disconnect(); Termina a ligação com o Drone
void setConfigOption
(ARDrone.ConfigOption opção,
String valor);
Define definições do Drone, como altura
máxima, altura mínima, entre outros, o primeiro
parâmetro é representado por uma lista que pode-
se escolher qual a definição a escolher, como
37
segundo parâmetro é mandado o valor da
definição escolhida anteriormente.
void selectVideoChannel
(ARDrone.VideoChannel);
Define qual a camara que o Drone transmite,
necessita como parâmetro de entrada de um dos
seguintes valores (HORIZONTAL_ONLY,
VERTICAL_ONLY,
VERTICAL_IN_HORIZONTAL,
HORIZONTAL_IN_VERTICAL)
void trim(); Calibra os sensores referentes a Pitch, Yaw e Roll
void
addStatusChangeListener(ARDrone
drone);
Adiciona o objeto Drone, a função toma o
conhecimento de todas as constantes incluídas no
objeto, como exemplo portas de comunicação,
endereço IP, etc.
void addNavDataListener
(ARDrone drone);
Adiciona o objeto Drone, a função toma o
conhecimento de todas as constantes incluídas no
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
As funções que definem ações no Drone estão presentes na Tabela 4:
Tabela 4- Funções de movimento da biblioteca JavaDrone
void sendEmergencySignal(); Envia sinal de emergência, os motores param
automaticamente.
void land(); Inicia a aterragem
void takeOff(); Inicia a descolagem
void move(float, float, float, float) ;
Move o Drone
O primeiro parâmetro move o Drone no sentido
esquerda/direita. Com valores positivos move-se
para a direita, valores negativos move para a
esquerda. O segundo parâmetro move o Drone
para a frente/trás sendo valores negativos o Drone
move se para frente e valores negativos o Drone
move para trás. O terceiro parâmetro move o
Drone para cima/baixo, um valor positivo o Drone
sobe se for negativo desce.
O quarto parâmetro faz o Drone rodar sobre si
mesmo, valores positivos o Drone roda para a
direita, valores negativos o Drone roda para a
esquerda
38
5.2 Programa de Controlo Manual
O programa de controlo manual foi desenvolvido na linguagem de programação java,
criando um ambiente gráfico (Figura 32) que tem como função simplificar a interação
com o Drone. Nesse ambiente gráfico é possível controlar o Drone, visualizar os valores
dos sensores, a imagem transmitida pelo Drone, assim como a imagem depois de ser
processada.
Figura 32- Ambiente Gráfico para 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);
O botão de EMERGÊNCIA irá parar automaticamente os motores do Drone e utilizará a
seguinte função:
drone.sendEmergencySignal();//envia sinal de emergência
Relativamente ao controlo, o Drone é capaz de descolar mas antes necessita de estar
num plano horizontal para que se consiga calibrar e preparar para a descolagem, se o
comando “AT*FTRIM” não for enviado o Drone não será capaz de se estabilizar durante
o voo, para o Drone descolar é usado o seguinte código:
39
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:
drone.move(0,-vel,0,0); //Drone move-se para a frente
drone.move(0,vel,0,0); //Drone move-se para trás
drone.move(vel,0,0,0); //Drone move-se para a direita
drone.move(0,0,-vel,0); //Drone move-se para baixo
drone.move(0,0,0,vel); //Drone roda em torno si próprio para o lado
direito
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:
drone.land();//envia o comando para aterrar
5.3 Navegação Autónoma do Drone
Na realização da navegação autónoma do Drone foi necessário juntar o módulo de
processamento de imagem com o módulo de navegação autónoma (Figura 33), o
módulo de navegação autónoma consiste em interpretar os valores enviados do
processamento de imagem, conseguindo assim mover o Drone através da imagem
transmitida pelo próprio.
40
Figura 33- Interação entre processamento de imagem e algoritmo de navegação
Depois da imagem ser enviada pelo Drone é processada no modulo de processamento
de imagem o que irá fornecer ao sistema de navegação, informações necessárias para a
realização do objetivo, essa informação será um valor inteiro que poderá variar entre 1 e
4 para a câmara da frente ou entre 1 e 5 para a câmara inferior. Quando usada a câmara
da frente o objetivo é que o Drone siga a folha que estará há sua frente movendo-se
tanto na horizontal como na vertical, quando usada a câmara inferior o Drone deverá
seguir em frente até se aperceber que a folha está por baixo dele, depois de a folha estar
no centro da imagem o Drone deverá aterrar.
5.3.1 Navegação Autónoma com a Câmara Frontal
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)
41
Figura 34- Algoritmo usado na navegação autónoma com a câmara frontal
Quando o botão é pressionado, o Drone descola e invoca a função startseguefolha(),
essa função cria um ciclo que de 1200 em 1200 milissegundos chama a função
seguefolha(). A função seguefolha() tem definida a velocidade a que o Drone se move e
tem também uma variável que é incrementada sempre que alguma ação é enviada para o
Drone, e essa variável vai possibilitar que este ciclo termine quando chegar ao valor
pré-definido. O Drone sabe que ações deve tomar devido á função getvalorfrente() que
retorna um valor inteiro entre 1 e 4, sendo o valor 1 o Drone move-se para a esquerda,
sendo invocado o seguinte código:
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:
42
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++;
}
Se a função getvalorfrente() não transmite nenhum desses valores nenhuma ação é
enviada para o Drone e o Drone entra em modo pairar.
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.
5.3.2 Navegação Autónoma com a Câmara Inferior
Na navegação autónoma com a câmara inferior o algoritmo é idêntico ao anterior mas
mais complexo, foi também adicionado um botão no ambiente gráfico, Aterra no centro
que quando é pressionado dá início ao algoritmo (Figura 35).
43
Figura 35- Algoritmo usado na navegação autónoma com a câmara de baixo
Quando o botão é pressionado o Drone descola e invoca a função startaterracentro(),
que invoca o seguinte código:
private void startaterracentro()
{
Thread thread = new Thread(new Runnable()
{
public void run()
{
while(running){
if(video.getimage()==1 || image==1){
image=1;
try {
Thread.sleep(1300);
} catch (InterruptedException ex) {
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);
}
44
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:
float aux= (float)0.5;
System.out.println("TEM DE ANDAR PARA A FRENTE");
jTextArea1.append("\t \t Tem de andar para a frente \n");
try{
drone.move(0,-aux,0,0);
}
catch (IOException ex) {
Logger.getLogger(Comando.class.getName()).log(Level.SEVERE, null,
ex);
}
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)
{
45
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)
Figura 36- Exemplo prático
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:
46
if(video.getvalorbaixo()==5){
System.out.println(" PODE ATERRAR ");
jTextArea1.append("\t \t PODE ATERRAR PODE ATERRAR \n");
drone.land();
running=false;
}
A Figura 37 ilustra esse exemplo.
Figura 37- Exemplo de folha no centro
Assim foi possível implementar um sistema de navegação autónoma para a câmara
inferior, existindo um único problema que reverte para quando o Drone durante o
algoritmo perde a folha, possivelmente devido a sua instabilidade, não foi
implementado nenhum código para resolver essa situação, devido á falta de sensores na
extremidade do Drone, sem esses sensores o Drone não se consegue aperceber de
possíveis obstáculos logo por mais evoluído que fosse esse código levaria sempre á
queda do Drone.
47
48
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.
Em cada parte será explicada a realização da mesma e em que consistiu.
6.1 Navegação do AR.Drone usando um Dispositivo com
Android
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.
A navegação é bastante intuitiva o que torna a primeira experiência bastante agradável.
(Figura 38).
49
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)
Figura 39- Definição da altitude máxima
Figura 40- Definição de valores da velocidade
50
Este teste serviu como primeiro contato com a plataforma móvel e as suas
funcionalidades.
6.2 Navegação semiautónoma do Drone
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).
Figura 41- Ambiente Gráfico da aplicação de controlo com o computador
51
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.
6.3 Navegação Autónoma Utilizando a Imagem da Câmara
Inferior
Depois de ligados o módulo de navegação e o módulo de processamento de imagem
foram realizados os testes necessários para tentar movimentar o Drone autonomamente
usando estes dois módulos em conjunto.
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.
Figura 42- Condição de aterrar verificada
52
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.
Figura 43-Exemplo do Drone no modo de navegação autónoma com a câmara inferior
É também gerado um documento de texto contendo o valor do erro entre o centro da
folha branca e o centro da nossa imagem.
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)
Em que “a” é a distância em x do centro da folha ao centro da câmara, “b” é a distância
em y do centro da folha ao centro da câmara e “c” é a hipotenusa do triângulo, que neste
caso é o valor que é considerado como erro para construir o gráfico.
53
Figura 44- Gráfico do erro desde que deteta folha até aterrar
Na Figura 45 é mostrado um exemplo de como é calculado o erro apresentado no
gráfico acima.
A linha verde representa a distância do centro da folha ao centro da imagem no eixo do
x, a linha preta representa a distância do centro da folha ao centro da imagem no eixo do
y. A linha amarela é a distância que vai ser usada para calcular o nosso erro e construir
o gráfico. O quadrado branco é onde supostamente a folha branca terá que estar para
que o Drone a considere no centro.
54
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.
6.4 Navegação Autónoma Utilizando a Imagem da Câmara
Frontal
A navegação utilizando a câmara frontal, é bastante semelhante á navegação usada com
a câmara inferior, no entanto, nesta o objetivo não é aterrar, mas sim seguir uma folha
branca.
Com este algoritmo o Drone move-se na horizontal e na vertical, movendo-se sempre
com o objetivo de seguir a folha, tal como pode-se observar na Figura 46.
55
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.
56
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.
Irão ser abordados também os problemas confrontados durante a realização deste
projeto.
7.1 Objetivos 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.
Nele foram aplicados também bastantes conhecimentos adquiridos ao longo do nosso
percurso académico, tal como a programação em java e orientada a objetos o que
também facilitou o desenvolvimento do projeto
A aplicação final foi a pretendida, conseguiu-se desenvolver um sistema de navegação
autónomo para o Drone, conseguindo aplicar um algoritmo para a câmara frontal do
Drone que consiste em que o Drone siga uma folha branca tanto na horizontal como na
vertical, como também aplicar um algoritmo para a câmara inferior do Drone que
consiste em o Drone descole, siga em frente até encontrar a folha e depois de calcular o
centro da folha aterre.
57
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.
Outro possível melhoramento, seria a colocação de sensores laterais no Drone, o que
tornaria a sua navegação mais segura e fiável, sendo assim também facilitada a tarefa de
detetar obstáculos.
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.
Deteção de faces e realidade aumentada serão dois projetos interessantes, e que
futuramente iriam ser proveitosos para os alunos que desejassem continuar o nosso
trabalho, pois a realidade aumentada é uma tecnologia que tem vindo a crescer de dia
para dia.
58
Referências Bibliográficas
[1] “eps,” [Online]. Available: http://www.eps.ufsc.br/disserta99/vieira/cap2.html. [Acedido
em Setembro 2013].
[2] “Fperroti,” [Online]. Available:
https://fperrotti.wikispaces.com/Introdu%C3%A7%C3%A3o. [Acedido em Janeiro 2013].
[3] “Pet,” [Online]. Available: http://www.pet.joinville.udesc.br/atividades/projetos/lego/.
[Acedido em Julho 2013].
[4] “ODIA,” [Online]. Available: http://odia.ig.com.br/portal/rio/tecnologia-de-ponta-em-
seguran%C3%A7a-1.429545. [Acedido em Agosto 2013].
[5] “Aeryon,” [Online]. Available: http://www.aeryon.com/products.html. [Acedido em 09
2013].
[6] “Inovação Tecnológica,” [Online]. Available:
http://www.inovacaotecnologica.com.br/noticias/noticia.php?artigo=robo-curiosity-
materia-organica-marte&id=010130121204. [Acedido em Setembro 2013].
[7] T. o. r. legs, em Types of robot legs, p. 232.
[8] “flickrhivemind,” [Online]. Available:
http://farm8.static.flickr.com/7186/6941655033_d88afd4477_m.jpg. [Acedido em
Setembo 2013].
[9] “Voltairnet,” [Online]. Available: http://www.voltairenet.org/article175729.html.
[Acedido em Setembro 2013].
[10] “gnom-rov,” [Online]. Available: http://www.gnom-rov.com/products/super-gnom/.
[Acedido em 2013 Agosto].
[11] “Draganfly,” [Online]. Available: http://www.draganfly.com/uav-helicopter/draganflyer-
x4es/specifications/. [Acedido em Dezembro 2012].
[12] “Wikipédia,” [Online]. Available: http://pt.wikipedia.org/wiki/Elbit_Hermes_450.
[Acedido em Agosto 2013].
[13] “Military,” [Online]. Available: http://military.wikia.com/wiki/General_Atomics_MQ-
1_Predator. [Acedido em Setembro 2013].
[14] “Wikipédia,” [Online]. Available: http://en.wikipedia.org/wiki/CMOS . [Acedido em
Agosto 2013].
[15] “Wikipédia,” [Online]. Available:
59
http://pt.wikipedia.org/wiki/Vis%C3%A3o_computacional. [Acedido em 2013 Fevereiro].
[16] “Wikipédia,” [Online]. Available: http://en.wikipedia.org/wiki/H263. [Acedido em Março
2013].
[17] “Wikipédia,” [Online]. Available: http://en.wikipedia.org/wiki/Grayscale. [Acedido em
Março 2013].
[18] “StackOverflow,” [Online]. Available:
http://stackoverflow.com/questions/16525679/find-values-in-array-and-return-index.
[Acedido em 2013 Abril].
[19] “Backgroundfordesktop,” [Online]. Available:
http://www.backgroundfordesktop.com/2013/06/world-nature-hd-wallpapers.html.
[Acedido em Maio 2013].
[20] “Ostermiller,” [Online]. Available: http://ostermiller.org/dilate_and_erode.html. [Acedido
em Abril 2013].
[21] “ARDRONE open API platform,” [Online]. Available: https://projects.ardrone.org/.
[22] “ARDroneForP5,” [Online]. Available: http://kougaku-
navi.net/ARDroneForP5/index_en.html.
[23] “javadrone,” [Online]. Available: https://code.google.com/p/javadrone/.
[24] “Público,” [Online]. Available: http://www.publico.pt/tecnologia/noticia/drone-aquatico-
portugues-ganha-concurso-do-engadget-1588248#/0. [Acedido em Setembro 2013].
[25] “Wikipédia,” [Online]. Available:
http://pt.wikipedia.org/wiki/Ve%C3%ADculo_a%C3%A9reo_n%C3%A3o_tripulado#cite_n
ote-12. [Acedido em Setembro 2013].
[26] “twendyone,” [Online]. Available: http://twendyone.com/concept_e.html. [Acedido em
Setembro 2013].