Higordtallescosta

UNIVERSIDADE FEDERAL DO ESPRITO SANTO
CENTRO TECNOLGICO
DEPARTAMENTO DE ENGENHARIA ELTRICA
PROJETO DE GRADUAO
CONTROLE DE UM ROB MVEL
UTILIZANDO A TECNOLOGIA ZIGBEE
E A VISO COMPUTACIONAL
HIGOR D' TALLES COSTA
VITRIA ES
DEZEMBRO/2007
Parte escrita do Projeto de Graduao do
aluno Higor D' Talles Costa, apresentado
ao Departamento de Engenharia Eltrica
do Centro Tecnolgico da Universidade
Federal do Esprito Santo, para obteno
do grau de Engenheiro Eletricista.
VITRIA ES
DEZEMBRO/2007
COMISSO EXAMINADORA:
________________________________________
Prof
a
. Dr
a
. Raquel Frizera Vassallo
Orientadora
________________________________________
Prof. Dr. Evandro Ottoni Teatini Salles
Examinador
________________________________________
Prof
a
. Dr
a
. Eliete Maria de Oliveira Caldeira
Examinadora
Vitria - ES, 21, Dezembro de 2007.
DEDICATRIA
Aos meus pais, familiares e amigos, por toda a ajuda, incentivo e f.
i
AGRADECIMENTOS
Agradeo primeiramente a Deus por ter me dado a fora, nimo e
discernimento para concluir este trabalho com xito.
Aos meus pais, David e Carolina, pelo incessante apoio e fora. Grandes
incentivadores. Agradeo pela f e confiana depositadas em mim durante todo o
curso de Engenharia Eltrica, e tambm durante o desenvolvimento deste trabalho.
Aos meus irmos, rico e Caroline, pelo apoio, f e amizade.
Prof
a
. Raquel Frizera Vassallo, orientadora deste trabalho, pela ateno e
disponibilidade. A proposta do trabalho foi bastante desafiadora e alinhada com meus
interesses pessoais e profissionais. No poderia deixar de agradec-la pelo incrvel
suporte e conhecimento tcnico em Viso Computacional que foram amplamente
aplicados neste trabalho. Por ela tenho enorme admirao, respeito e confiana.
Ao Julio e ao Clebson, estudantes de Engenharia de Computao, que
gentilmente cederam os cdigos que serviram de base para a parte de Viso
Computacional.
Ao Christiano, aluno de Doutorado, por ter cedido o cdigo do MSP430 que
serviu de base para a aplicao desenvolvida para o rob.
Prof
a
. Carmen, responsvel pelo Laboratrio de Robtica Educacional, por
ter gentilmente aberto as portas desse laboratrio para que eu trabalhasse na fase de
testes. Sem isso, certamente eu no teria atingido os resultados to rapidamente.
Ao Thierry, monitor do Laboratrio de Robtica Educacional, pelo apoio,
momentos de bate-papo e tambm pela curiosidade, pois isso me fez reavaliar alguns
conceitos aplicados a este trabalho. Essas reflexes foram muito importante para a
tomada de algumas decises de projeto.
Finalmente, a todos aqueles cujos nomes no mencionei, embora tenham tido
sua importncia em muitos momentos da minha vida acadmica. Agradeo tambm
aos que contriburam direta ou indiretamente para que este trabalho se tornasse
possvel.
ii
LISTA DE FIGURAS
1 - PLACA PRINCIPAL DO ROB..................................................................................................................15
2 - ESQUEMA DE LIGAO DA PLACA PRINCIPAL................................................................................16
3 - ESQUEMA DE LIGAO DO PC PLACA PRINCIPAL......................................................................16
4 - CONJUNTO DE DESENVOLVIMENTO DA MAXSTREAM..................................................................19
5 - ANLISE DE CONEXO COM O X-CTU................................................................................................20
6 - TELA DE CONFIGURAO DA COMUNICAO SERIAL.................................................................21
7 - TELA DE TESTES DO X-CTU....................................................................................................................21
8 - TELA DE CONFIGURAO DO XBEE....................................................................................................22
9 - SINTAXE PARA O MODO DE COMANDO AT.......................................................................................23
10 - EXEMPLOS DE PROGRAMAO EM MODO DE COMANDO AT.....................................................23
11 - PINAGEM DO MSP430F149.......................................................................................................................26
12 - COMUNICAO SERIAL ENTRE XBEE E MICROCONTROLADOR.................................................27
13 - ROB E ALVO COM SUAS RESPECTIVAS CORES..............................................................................31
14 - RECONHECIMENTO DE CORES..............................................................................................................31
15 - REFERNCIAS DO SISTEMA PTICO....................................................................................................32
16 - FORMAO DA IMAGEM EM UMA CMERA PERSPECTIVA.........................................................35
17 - MODELO DA CMERA PERSPECTIVA COM PROJEO DE PONTO..............................................36
18 - RELAO DO ERRO COM A TAREFA A SER EXECUTADA..............................................................37
19 - RESPOSTA IDEAL DO CONTROLADOR................................................................................................39
20 - AMBIENTE DE TESTE...............................................................................................................................44
21 - CORES SELECIONADAS COM O SISTEMA EM REPOUSO.................................................................49
22 - CORES SELECIONADAS E RUDOS GERADOS COM O SISTEMA EM FUNCIONAMENTO.........49
iii
LISTA DE TABELAS
1 - CARACTERSTICAS DO PADRO 802.15.4..............................................................................................17
2 - CARACTERSTICAS DO XBEE E DO XBEE PRO....................................................................................18
3 - COMPARAO DE TEMPOS DE RESPOSTA ENTRE ZIGBEE E BLUETOOTH.................................18
iv
GLOSSRIO
BSL BOOTSTRAP LOADER, UTILIZADO PARA PROGRAMAO DO MSP430.
CAMSHIFT CONTINUOUSLY ADAPTATIVE MEAN SHIFT. ROBUSTA TCNICA INTERATIVA E
NO-PARAMTRICA PARA ENCONTRAR UM MODO DE DISTRIBUIO DE
PROBABILIDADE.
DCO OSCILADOR CONTROLADO DIGITALMENTE.
DI DATA IN, PINO DE ENTRADA DE DADOS DO XBEE.
DO DATA OUT, PINO DE SAA DE DADOS DO XBEE.
FRAME CADA QUADRO CAPTURADO PELA CMERA.
HUE CANAL DA MATIZ NO SISTEMA DE COR HSV.
HSV SISTEMA DE COR.
MEAN SHIFT ALGORTMO DE MULTIPROCESSAMENTO DE DADOS GERALMENTE UTILIZADO
EM APLICAES DE VISO COMPUTACIONAL E PROCESSAMENTO DE IMAGENS.
MSP430 MICROCONTROLADOR FABRICADO PELA TEXAS INSTRUMENTS.
OPENCV BIBLIOTECA DE PROCESSAMENTO DE IMAGENS DESENVOLVIDA PELA INTEL.
RISC COMPUTADOR COM CONJUNTO REDUZIDO DE INSTRUES.
WEBCAM TIPO DE CMERA EM GERAL UTILIZADA EM COMPUTADORES E NO COSTUMA
APRESENTAR ALTA QUALIDADE NA CAPTURA DE IMAGENS, ALM DE SER UM
DISPOSITIVO QUE REALIZA AJUSTES AUTOMTICOS DA IMAGEM SEM A
INTERVENO DO USURIO.
v
SUMRIO
DEDICATRIA.........................................................................................................I
AGRADECIMENTOS..............................................................................................II
LISTA DE FIGURAS..............................................................................................III
LISTA DE TABELA...............................................................................................IV
GLOSSRIO.............................................................................................................V
SUMRIO................................................................................................................VI
RESUMO..............................................................................................................VIII
1 INTRODUO.......................................................................................................9
1.1 Motivao........................................................................................................9
1.2 Trabalhos Similares.......................................................................................10
1.3 Descrio e Objetivo do Projeto....................................................................11
2 HARDWARE DO SISTEMA...............................................................................14
2.1 Introduo......................................................................................................14
2.2 Placa Principal do Rob.................................................................................14
2.3 Tecnologia ZigBee.........................................................................................17
2.3.1 XBee e suas Caractersticas..................................................................17
2.3.2 Programa de Configurao e Testes.....................................................19
2.3.3 Mtodos de Programao.....................................................................22
2.4 O Microcontrolador MSP430.........................................................................24
2.4.1 Principais Caractersticas do Microcontrolador....................................25
2.4.2 O Programa do MSP430.......................................................................26
2.5 Conexo do XBee com o MSP430.................................................................27
vi
3 PROCESSAMENTO DE IMAGENS .................................................................29
3.1 Introduo......................................................................................................29
3.2 Tcnica Utilizada...........................................................................................29
3.3 Consideraes Iniciais de Projeto..................................................................32
3.3.1 Modelagem Matemtica do Sistema ptico.........................................33
3.3.1 Sistema de Orientao..........................................................................39
3.4 Captura e Processamento da Imagem.............................................................40
4 SISTEMA COMPLETO E TAREFA PROPOSTA...........................................42
4.1 Introduo......................................................................................................42
4.2 Montagem do Sistema e Detalhes de Funcionamento....................................42
4.3 Tarefa Proposta..............................................................................................44
5 EXPERIMENTO...................................................................................................46
5.1 Introduo......................................................................................................46
5.2 Teste e Anlise dos Resultados......................................................................46
6 CONCLUSO.......................................................................................................50
6.1 Trabalhos Futuros..........................................................................................51
APNDICE A...........................................................................................................52
APNDICE B...........................................................................................................57
REFERNCIAS BIBLIOGRFICAS...................................................................78
vii
RESUMO
Este trabalho aborda a criao de um sistema de controle de robs mveis
utilizando-se para isso tcnicas de viso computacional e recursos de comunicao
sem fio providos pelo dispositivo XBee que implementa a tecnologia ZigBee. O rob
foi tambm equipado com uma placa de controle com um microcontrolador MSP430,
da Texas Instruments. A tarefa principal deste trabalho visa a movimentao de um
rob em um ambiente utilizando-se realimentao por imagem e troca de informaes
distncia. Para isso, foi utilizada uma cmera com inclinao e altura conhecidas. A
cmera foi direcionada para o ambiente em que o rob executaria a tarefa, e a
geometria projetiva da cena foi usada para definir o controle. O rob e o ponto destino
foram marcados com uma indicao colorida para permitir o seguimento de cor
durante a movimentao do rob. Com o auxlio de algumas relaes matemticas
pode-se calcular as velocidades linear e angular de tempos em tempos a fim de
atualizar as velocidades de cada roda do rob para que este atingisse o objetivo
proposto.
viii
1 INTRODUO
1.1 Motivao
Muitos trabalhos tm sido desenvolvidos para que as habilidades de robs
sejam aperfeioadas e ampliadas. Existem robs para executar tarefas perigosas, como
o caso de trabalhos realizados nas proximidades de vulces em atividade, e robs
para executar tarefas do dia-a-dia, como o caso de robs projetados para cuidar de
crianas e at mesmo para brincar. Esses robs especializados, e com sensoriamento
variado envolvendo tcnicas avanadas tanto de eletrnica quanto de computao, so
capazes de agir sozinhos descobrindo ambientes, aprendendo e at mesmo tomando
decises.
Mesmo com as diversas possibilidades que as tecnologias atuais permitem,
muitas vezes no vivel utilizar robs to avanados em tarefas nem sempre to
complicadas. Devido a isso, o desenvolvimento de robs mais simples, capazes de agir
em grupo, tem sido cada vez mais freqente para aplicaes que envolvem diversos
mdulos trabalhando em conjunto para atingir um objetivo [1, 2]. Esta alternativa
oferece vantagens potenciais em termos de flexibilidade de funcionamento [3, 4].
Existem diversas aplicaes em que essa metodologia faz-se necessria, como o caso
de linhas de montagem e outras tarefas que exigem o trabalho em equipe, tal como
ocorre com seres humanos.
Alguns trabalhos envolvendo cooperao no s so desenvolvidos para que os
componentes do grupo hajam em conjunto, mas tambm visam o compartilhamento de
recursos tais como cmeras, dados de posicionamento, etc [7]. Esse tipo de cooperao
baseada no comportamento humano, onde nem todos os membros de uma equipe tm
as mesmas habilidades, embora possam suprir suas necessidades buscando recursos
em outros componentes do grupo.
A viso computacinal pode ser aplicada a diversas situaes. Hoje em dia tem
sido cada vez mais difundidas aplicaes desenvolvidas para ambientes inteligentes.
Em geral, aplicaes como essas consideram vrios pontos fixos para a observao da
9
cena. No entanto, em alguns casos, as cmeras se movem a fim de acompanhar os
objetos a serem seguidos no ambiente.
No que diz respeito a trabalhos desenvolvidos por times de robs, em alguns
casos, pode-se ter um observador da cena que controla os demais membros da equipe
na execuo de tarefas. Esse papel pode ser feito por um rob lder, que tambm se
locomove no ambiente, ou mesmo por um observador fixo. Esse trabalho procura
explorar este fato utilizando-se de um observador fixo para fazer o controle de um
rob observado que se locomove no ambiente. Alm disso, nessas aplicaes preciso
ter um sistema de comunicao, que neste caso, isso feito utilizando-se a tecnologia
ZigBee.
1.2 Trabalhos Similares
Muitos trabalhos j foram desenvolvidos a respeito de cooperao de robs. As
aplicaes mais comuns envolvem robs que executam tarefas como empurrar caixas,
carregar objetos, realizar formaes especficas e agir em sincronia [1, 2, 5].
Em geral, um dos meios de comunicao mais utilizados a porta serial, padro
RS-232, em que as partes se conectam por meio de fios sendo um para envio de dados,
TX, e outro para recebimento, RX. Esse tipo de comunicao funciona bem em
sistemas em que o rob tem movimentos bastante limitados ou mesmo em sistemas
articulados com base esttica.
Em adio ao sistema de comunicao, muitos projetos contam tambm com o
processamento de imagem a fim de localizar texturas e objetos no ambiente. Essas
informaes so teis para que o rob consiga se locomover no ambiente e tambm
para que a tarefa a ser executada seja bem sucedida, pois leva em considerao
marcaes existentes ou propositalmente inseridas no ambiente. Alguns trabalhos
utilizam imagens omnidirecionais [6] enquanto outros utilizam imagens projetivas [8].
Dependendo do tipo de imagem capturada pela cmera, a complexidade do problema
pode ser aumentada ou diminuda significativamente. Imagens omnidirecionais
envolvem complexidades maiores e podem gerar problemas ou imprecises de acordo
10
com tamanho do objeto a ser detectado. Ainda assim, com esse sistema pode-se
movimentar o rob levando-o a qualquer ponto visvel da imagem [14]. Este tipo de
imagem tem aplicaes mais interessantes quando a cmera embarcada em sistemas
mveis. Por outro lado, imagens projetivas envolvem complexidades menores e so
mais indicadas para sistemas em que a cmera permanece parada enquanto os robs se
movimentam em seu campo de viso.
Para o caso de robs cooperativos tal como proposto em [14], interessante
que os componentes do grupo consigam se comunicar sem a necessidade de fios e
devido a isso, faz-se necessria a comunicao por um meio seguro, veloz e com alta
capacidade de adio de ns ao sistema. A utilizao do XBee garante ao sistema toda
a flexibilidade e independncia necessrias para que os robs se locomovam
livremente ao executar as tarefas.
1.3 Descrio e Objetivo do Projeto
Sistemas como os anteriormente apresentados podem se tornar ainda mais
interessantes quando combinados com mdulos de comunicao sem fio. Isso confere
maior autonomia aos robs, j que no estariam sujeitos a limitaes impostas por
cabos tais como altos custos de instalao, necessidade de espao fsico adequado, e
tambm perda de informaes devido s caractersticas intrnsecas do cabo. No
entanto, perdas tambm podem ocorrer utilizando-se comunicao sem fio, mas devido
facilidade de instalao estas podem ser minimizadas utilizando-se algoritmos
corretores de erros. Pode-se tambm utilizar sistemas de comunicao multi-rota. Este
tipo de sistema pode reduzir sensivelmente a ocorrncia de falhas de comunicao.
Para viso computacional, utiliza-se imagens projetivas devido simplicidade
de processamento quando comparado ao processamento de imagens omnidirecionais.
Os robs so equipados com a placa de controle criada no projeto [9] e esta tem
como controlador principal o microcontrolador MSP430F149 da Texas Instruments
(TI). Essa placa conta com diversos mdulos funcionais tais como Ponte H, interface
J-Tag, interface de programao serial para o programador BSL (BootStrap Loader),
11
interface de controle via comunicao serial, entre outros que sero detalhados em
outros itens.
Cada rob conta tambm com uma placa de desenvolvimento contendo um
mdulo de comunicao sem fio da tecnologia ZigBee. O mdulo utilizado foi o XBee
do fabricante MaxStream. Esse mdulo possui diversas caractersticas adequadas a
operaes seguras de redes e tambm uma capacidade bastante elevada de
endereamento de ns de rede. Alm disso, trata-se de um dispositivo com um
consumo de energia extremamente baixo e capaz de trabalhar com distncias bastante
elevadas, cerca de 100 metros sem antenas especiais. Este sistema apresenta boas
caractersticas de transmisso operando na faixa de freqncia de 2.4 GHz, no Brasil.
Para auxiliar a movimentao dos rob no ambiente, o sistema tambm
equipado com uma cmera para captura das imagens que sero processadas. Para isso,
instalada uma cmera no ambiente de testes e com as imagens capturadas possvel
seguir os rob e mov-lo para os pontos de interesse definidos de acordo com a tarefa
a ser executada. A biblioteca de processamento de imagens utilizada neste trabalho
desenvolvida pela Intel e tem cdigo fonte aberto. Ela chamada OpenCV e possui
diversas funes que tornam mais fcil a deteco e o seguimento de cor, tal como
feito neste trabalho. A verso utilizada a 1.0.
O rob utilizado neste trabalho construdo em acrlico e utiliza a placa de
circuito desenvolvida em [9]. Suas dimenses so de aproximadamente 10x15 cm.
Possui 3 rodas, trao diferencial, e para control-lo so enviadas as velocidades
linear, v, e angular, , para a porta serial da placa embarcada que controla suas
funes. Internamente, no programa do MSP430, essas velocidades so utilizadas para
compor as velocidades das rodas esquerda e direita. O rob alimentado por uma
bateria de chumbo a uma tenso de 14 volts. A tenso de alimentao se sua placa
principal de 9 volts, conseguidos com um regulador de tenso.
Com tudo devidamente ajustado, ento possvel a realizao de testes. O
principal objetivo deste trabalho fazer com que um rob marcado com duas cores de
identificao, uma na parte traseira e outra na dianteira, partindo de uma orientao
qualquer no plano de execuo da tarefa, consiga chegar ao ponto marcado como
12
destino, e marcado com uma terceira cor. A tarefa realizada tendo-se como base o
seguimento de cor desenvolvido com funes da biblioteca OpenCV. Toda a
comunicao feita do ponto fixo para o rob, isto , o rob no envia informaes.
13
2 HARDWARE DO SISTEMA
2.1 Introduo
A placa de circuito principal, que controla as funes do rob foi concebida no
projeto [9]. Apesar de ser composta por diversos mdulos funcionais, apenas alguns
so relevantes a este projeto. Dentre eles, os principais so:
interface de programao via porta serial;
interface de controle via porta serial;
ponte H.
A placa descrita acima conectada ao mdulo de Rdio Freqncia (RF),
XBee, e este conectado ao MSP430 via porta serial. O mdulo RF apresenta muitas
facilidades em relao comunicao, j que, uma vez ajustado, a comunicao feita
de modo transparente e descomplicado. As caractersticas desse transceptor podem ser
vistas em [12], no entanto, algumas das suas principais caractersticas relevantes a este
projeto so:
operao na freqncia no-licenciada de 2.4 GHz;
taxas de transmisso relativamente altas quando comparadas a tecnologias
como bluetooth e WiFi;
baixo consumo.
Os detalhes funcionais dos circuitos citados, bem como as ligaes entre os
mdulos e os ajustes necessrios para que tudo funcione conforme esperado, so
descritos nos prximos itens.
2.2 Placa Principal do Rob
A placa principal do rob foi desenvolvida no projeto [9]. Essa a placa de
controle do rob e tem como controlador de funes o microcontrolador
MSP430F149.
14
Dentre os circuitos funcionais dessa placa, pode-se destacar aqueles que so
essenciais para este projeto e que j foram citados acima. Alguns mdulos no so
utilizados ou porque no so teis a este projeto ou porque no foram devidamente
testados e por isso seu uso no foi considerado, como o caso do circuito responsvel
pela interface J-Tag do MSP430. A placa citada pode ser vista na Figura 1 com seus
principais circuitos em destaque.
Devido ao fato dessa placa ainda no contar com um manual de utilizao, faz-
se necessrio o detalhamento do cabo de comunicao serial, e tambm de algumas
configuraes relativas a pinagem das partes em destaque da figura acima. Na Figura
2, pode-se ver os detalhes necessrios da pinagem para que as ligaes sejam
realizadas de maneira correta. Na Figura 3, pode-se ver a configurao do cabo
utilizado para gravao do MSP430 e tambm para o controle da placa.
15
Figura 1: Placa principal do rob.
16
Figura 2: Esquema de ligao da placa principal.
Figura 3: Esquema de ligao do PC placa principal.
2.3 Tecnologia ZigBee
Hoje em dia tem sido cada vez mais comum a busca por tcnicas de transmisso
de dados sem fios. Diversos padres j foram concebidos e atendem hoje a quase todas
as necessidades tanto de clientes residenciais quando industriais. No entanto, um
desses padres, o ZigBee, merece especial destaque por suas caractersticas. Este
padro foi criado pela ZigBee Alliance com o intuito de prover comunicao sem fio
de modo confivel, com baixo consumo e com taxas razoveis de transmisso para
monitoramento e controle, alm de ser uma tecnologia aberta.
Este padro possui elevada capacidade de endereamento de pontos de rede
trabalhando em faixas de freqncias abertas e consumindo pouqussima potncia,
tanto em modo de operao normal quanto em modo standby. O padro ZigBee, IEEE
802.15.4, foi homologado em maio de 2003. Este padro tem como foco aplicaes de
rdio freqncia que requerem baixas taxas de transmisso de dados, baixo consumo
de potncia e rede segura. Este projeto utiliza um circuito chamado XBee. Este
circuito utiliza-se dessa tecnologia e desenvolvido pela MaxStream.
2.3.1 XBee e suas Caractersticas
Como j foi citado, o padro ZigBee apresenta muitas caractersticas
interessantes as quais o tornam muito superior em relao ao padro Bluetooth, IEEE
802.15.1. Para mais detalhes e comparaes entre os dois padres vide [13].
Nas Tabelas 1, 2 e 3, seguem algumas caractersticas importantes encontradas
no padro ZigBee e, em particular, nos dispositivos XBee e XBee Pro [12].
Padro Freqncias N de canais Tcnica de Modulao Taxa de dados
802.15.4
2.4 - 2.4835 GHz 16 (11 a 26) DSSS
1
, O-QPSK 250 kbit/s
868 - 870 MHz 1 (0) DSSS, BPSK 20 kbit/s
902 - 928 MHz 10 (1 a 10) DSSS, BPSK 40 kbit/s
Tabela 1: Caractersticas do ZigBee, padro 802.15.4.
1
DSSS (Direct Sequence Spread Spectrum), Espalhamento Espectral por Seqncia Direta.
17
XBee XBee Pro
Item Caractersticas Item Caractersticas
Ambiente interno / Urbano 30 m Ambiente interno / Urbano 100 m
Ambiente externo com visada At 100 m Ambiente externo com visada At 1500 m
Potncia de transmisso 1 mW (0 dBm) Potncia de transmisso 100 mW (20 dBm) EIRP
Sensibilidade de transmisso -92 dBm Sensibilidade de transmisso - 100 dBm
Corrente TX 45 mA (@ 3.3 V) Corrente TX 270 mA (@ 3.3 V)
Corrente RX 50 mA (@ 3.3 V) Corrente RX 55 mA (@ 3.3 V)
Corrente em baixa potncia < 10 A Corrente em baixa potncia < 10 A
Antena acoplada de fio - Antena RPSMA 2.4 GHz, 2.1 dBi
Tabela 2: Caractersticas do XBee e do XBee Pro.
Item Tempo de Resposta
ZigBee Bluetooth
Tempo de acesso a rede 30 ms 3 s
Tempo de transio dos dispositivos escravos dos
estado dormindo para o estado ativo
15 ms 3 s
Tempo de acesso ao canal 15 ms 2 ms
Tabela 3: Comparao de tempos de resposta entre ZigBee e Bluetooth.
O ZigBee foi concebido para operar em faixas de freqncias livres. Na Europa,
a operao feita em 868 MHz, nos Estados Unidos, em 915 MHz, e em muitas outras
regies do planeta, incluindo o Brasil, a operao feita em 2.4 GHz.
A Tabela 1 mostra algumas caractersticas dependentes da freqncia de
operao. Nessa tabela, pode-se ver a relao da freqncia com o nmeros de canais
de comunicao, tcnica de modulao suportada bem como as taxas de transmisso
que podem ser alcanadas.
Na Tabela 2 podem ser vistas as principais caractersticas dos modelos XBee e
do XBee Pro. Como pode ser notado, a relao entre distncia, potncia e taxa de
transmisso faz do padro ZigBee uma tima escolha para sistemas de monitoramento
remoto, visto que, uma simples bateria AA pode manter um sistema em funcionamento
por milhares de horas. A grande eficincia energtica do sistema possvel graas a
um amplo conjunto de comandos capaz de colocar e dispositivo em modo de
economia, fazer medio de bateria, nvel de sinal, entre outros. Com isso, desde que o
projeto seja bem desenvolvido pode-se aproveitar ao mximo suas caractersticas.
18
A Tabela 3 mostra informaes importantes respeito de tempos de resposta.
Para fins de comparao, nessa mesma tabela encontram-se os tempos de resposta
tpicos para o padro Bluetooth. O ZigBee superado apenas no tempo de acesso ao
canal, mas nos outros dois itens listados sua resposta muito mais rpida.
A Figura 4 mostra o conjunto de desenvolvimento da MaxStream utilizado
neste projeto e tambm os dois chips citados acima.
2.3.2 Programa de Configurao e Testes
No conjunto de desenvolvimento da MaxStream pode-se encontrar tambm um
aplicativo chamado X-CTU. Esse aplicativo utilizado para configurar as
caractersticas de funcionamento do XBee e tambm para testar a transmisso e o
recebimento de dados. Algumas das principais caractersticas desse programa esto
listadas abaixo:
facilidade de uso em testes de loopback a distncia;
mostra um Indicador de Potncia do Sinal Recebido (RSSI);
atualizao de firmware do XBee;
automaticamente detecta o tipo de mdulo;
19
Figura 4: Conjunto de desenvolvimento da MaxStream.
restaura parmetros de fbrica;
integra-se ao LabView e outras ferramentas de teste.
Este aplicativo muito importante e graas a ele possvel avaliar a intensidade
do sinal recebido e ento criar grficos e estudos assim como feito em [13]. A Figura 5
abaixo mostra uma maneira tpica de se utilizar o X-CTU em um teste de loopback.
As Figuras 6 e 7 mostram a tela de configurao da comunicao serial e a tela
de testes. Na tela de configurao, Figura 6, possvel fazer ajustes de velocidade de
comunicao, bits de paridade, entre outros. As configuraes utilizadas para este
trabalho podem ser vistas nessa figura. Na tela de testes, Figura 7, mostrada a barra
indicativa da potncia do sinal recebido pelo mdulo XBee conectado ao computador.
Nesse caso, o transmissor que est conectado ao computador envia o sinal a um outro
mdulo XBee equipado com um conector de loopback, e com isso, o sinal volta ao
transmissor e pode-se ento saber quantos pacotes enviados foram recebidos de volta,
e pode-se tambm medir a intensidade do sinal entre os mdulos de comunicao.
20
Figura 5: Anlise de conexo com o X-CTU.
21
Figura 6: Tela de configurao da comunicao serial.
Figura 7: Tela de testes do X-CTU.
Na Figura 8, mostrada a tela de configurao do circuito integrado do XBee.
Nesse janela possvel acessar todas as informaes do mdulo, mudar parmetros e
at mesmo atualizar o firmware. Caso sejam feitas configuraes inadequadas,
possvel tambm ajustar o dispositivo com os parmetros originais de fbrica.
2.3.3 Mtodos de Programao
Para modificar parmetros do mdulo RF tais como taxa de transmisso, modo
de comunicao (broadcast ou ponto-a-ponto), atualizao de firmware entre outros,
primeiro necessrio coloc-lo em Modo de Comando. Pode-se fazer isso pelo
programa X-CTU utilizando-se o modo Terminal ou mesmo selecionando-se
diretamente os campos que se deseja alterar. O Modo de Comando um estado em que
todos os caracteres recebidos so interpretados como comandos e no como dados.
Com isso, as informaes recebidas servem para alterar diretamente os campos de
configurao do dispositivo. H atualmente duas maneiras de se programar os mdulos
da MaxStream, a primeira chamada Modo de Comando AT e a segunda, Modo de
Comando API. A maneira mais simples de se alterar os parmetros pelo Modo de
Comando AT, j que mais simplificado e mais direto quando comparado ao outro
modo. Devido a isso, o Modo de Comando API no detalhado neste trabalho.
Para entrar em Modo de Comando AT, deve-se selecionar a aba Terminal do
aplicativo X-CTU. Feito isso, para comear o modo de comando basta enviar porta
22
Figura 8: Tela de configurao do XBee.
serial do XBee a seqncia de caracteres +++, sem as aspas, e em seguida pode-se
enviar qualquer comando vlido.
No caso de envio de comandos para o XBee enquanto ele est em modo de
operao, pode-se fazer necessrio o envio do comando CT (Command Mode
Timeout), que informa ao XBee quanto tempo o mdulo dever aguardar por um
comando at que saia automaticamente do modo de comando. Caso isso acontea, o
mdulo retorna automaticamente ao modo de operao. Aps configurado o CT, os
comandos de configurao podem ser enviados pelo usurio. Apesar de o mdulo
poder sair automaticamente do Modo de Programao possvel sair explicitamente
enviando o comando CN (Exit command mode).
A sintaxe dos comandos bem como um exemplo de programao no Modo de
Comando AT podem ser vistos nas Figuras 9 e 10, respectivamente.
Os modos de comando citados possibilitam a mudana dinmica dos parmetros
do dispositivo XBee. Dentre os comandos que podem ser aplicados ao dispositivo,
23
Figura 10: Exemplos de programao em Modo de Comando AT.
Figura 9: Sintaxe para o Modo de Comando AT.
pode-se citar alguns de extrema importncia ao se desenvolver projetos mais
elaborados e que fazem valer a adoo desse dispositivo. Alguns comandos com uma
breve descrio so listados abaixo:
ND (Node discover): descobre e reporta todos os mdulos de RF encontrados;
PL (Power level): seleciona/l a potncia utilizada para a transmisso;
SM (Sleep mode): configuraes para modo de baixo consumo;
VR (Firmware version): l a verso do firmware do mdulo RF.
Embora hajam muitas possibilidades para a melhor utilizao das
funcionalidades do XBee, este trabalho faz uso dos mdulos com suas configuraes
ajustadas de acordo com o padro de fbrica. Com isso, no feito uso direto dos
modos de comando apresentados, embora essa apresentao tenha sido feita para que o
horizonte de aplicaes pudesse ser melhor vislumbrado. Informaes mais detalhadas
a respeito do conjunto de comandos e de outras caractersticas prprias do dispositivo
da MaxStream podem ser encontradas em [12].
2.4 O Microcontrolador MSP430
Os microcontroladores da Texas Instruments (TI) so divididos em vrias
famlias de acordo com parmetros tais como tipo de memria de programa e
aplicao. Atualmente existem cinco famlias. So elas:
MSP430x1xx;
MSP430x2xx;
MSP430C3xx;
MSP430x4xx;
MSP430x5xx.
Este trabalho utiliza o MSP430F149, que um dispositivo de uso geral dotado
de uma grande variedade de perifricos. Trata-se de um dispositivo com CPU RISC de
16 bits, registradores de 16 bits e geradores de constantes. Estes ltimos contribuem
24
para a gerao de cdigos com mxima eficincia. O DCO (Oscilador Controlado
Digitalmente) permite reativar o dispositivo em menos de 6 s. Essa CPU opera em 8
MHz.
A famlia MSP430F14x ainda tem 2 temporizadores internos de 16 bits, um
rpido conversor Analgico/Digital (A/D) de 12 bits, duas interfaces seriais universais
Sncronas/Assncronas (USART) e ainda 48 pinos de Entrada/Sada.
Aplicaes tpicas incluem sistemas de sensoriamento que capturam sinais
analgicos, converte-os para sinais digitais e ento os processa e transmite a outro
sistema. Os contadores internos so ainda ideais para aplicaes de controle industrial
tais como controle digital de motores e medidores portteis.
2.4.1 Principais Caractersticas do Microcontrolador
O MSP430 possui diversas caractersticas interessantes e que o diferencia muito
de outros microcontroladores. Algumas dessas caractersticas esto listadas abaixo:
baixas tenses de alimentao (1.8 V a 3.6 V);
baixssima potncia consumida;
modo ativo: 280 A a 1 MHz, 2.2 V
modo standby: 1.6 A
modo desligado (reteno de memria RAM): 0.1 A
interface de comunicao serial (USART), que pode funcionar como UART ou
mesmo como interface SPI;
memria flash e RAM;
60 KB + 256 B de memria flash
2 KB de memria RAM
operao em 8 MHz;
alto desempenho dos cdigos compilados em C/C++ devido s caractersticas
de sua arquitetura e tambm por utilizar memria plana.
25
A Figura 11 mostra a pinagem do modelo utilizado neste trabalho. Suas
dimenses mximas so 12.20 x 12.20 x 1.20 mm e o encapsulamento do tipo S-
PQFP-G64.
2.4.2 O Programa do MSP430
O programa que controla as funes da placa principal do rob foi escrito em C
e a listagem completa pode ser vista no APNDICE A. Esse cdigo uma adaptao
do cdigo desenvolvido no trabalho [14].
No cdigo original, basicamente foi implementado um controle dos motores
utilizando Modulao por Largura de Pulso (PWM), um controlador integrador para
ser utilizado com os encoders e o tratamento de interrupes necessrio para o
recebimento de dados pela porta serial.
Para atender s necessidades deste trabalho, foram feitas algumas mudanas.
Como os encoders ainda no esto sendo utilizados, o cdigo relativo a esta funo foi
26
Figura 11: Pinagem do MSP430F149.
desativado. O controle do rob passou a ser feito pelo programa de viso
computacional, logo, o controlador integrador foi tambm removido do cdigo. O
programa do MSP sofreu tambm algumas alteraes a fim de torn-lo mais simples e
menos exigente em termos de processamento. Adicionalmente, um cdigo
identificador do rob foi inserido ao programa para assegurar que a tarefa seria
executada pelo rob correto, no caso de haverem mais robs envolvidos em uma
aplicao.
2.5 Conexo do XBee com o MSP430
Para alcanar os objetivos deste projeto, foi necessrio configurar tanto o
conjunto XBee quanto o MSP430 para que ambos pudessem trabalhar em perfeita
sintonia, aproveitando ao mximo as caractersticas particulares de cada um.
As principais configuraes so feitas em relao comunicao serial, visto
que, o XBee comporta-se como um meio fsico durante a transmisso e recepo de
dados. Sendo assim, para que um dado seja transmitido pelo XBee basta que o MSP o
direcione este dado a porta serial. O envio ocorre sem complicaes e diretamente.
Semelhantemente, para que o XBee receba dados, basta que estes sejam enviados para
seu endereo de rede por qualquer membro da rede autorizado a fazer isso, mas no
caso desse trabalho, isso feito pelo computador.
A Figura 12 ilustra melhor o processo de envio e recebimento de dados pelo
XBee.
27
Figura 12: Comunicao serial entre XBee e Microcontrolador.
Como pode ser visto na Figura 12, o mdulo de comunicao XBee muito
simples de ser utilizado, podendo ser facilmente integrado at mesmo a antigos
processadores de 8 bits. O XBee projetado para oferecer um meio de comunicao
sem fios e sem complicaes, e de maneira que seja transparente para o
microcontrolador no que diz respeito ao processo de transmisso e aos detalhes
particulares da comunicao via RF.
Por padro, o XBee opera no Modo Transparente. Quando opera nesse modo, o
mdulo opera como um simples repetidor de informaes, isto , todos os dados
recebidos pelo pino de entrada de dados, DI, so encaminhados para a transmisso em
RF. Quando os dados da transmisso RF so recebidos, eles so direcionados ao pino
de sada de dados, DO.
Se o mdulo no pode transmitir os dados imediatamente, no caso de j estar
ocupado com o recebimento de dados, estes dados recebidos serialmente so
armazenados no buffer de DI. Os dados so empacotados e enviados caso o tempo de
empacotamento chegue ao fim ou caso sejam completados 100 bytes, tamanho
mximo do pacote.
Caso o buffer de DI fique completamente cheio, necessrio implementar
algum software ou hardware a fim de controlar o fluxo de dados para que no ocorra
perda de dados por overflow entre o emissor e o receptor. Contudo, importante notar
que o XBee faz checagem de dados por checksum, e os pacotes que no passam no
teste so silenciosamente descartados.
28
3 PROCESSAMENTO DE IMAGENS
3.1 Introduo
O processamento de imagens muito utilizado em robtica. Essa tcnica agrega
boas possibilidades s funcionalidades dos robs.
Diversas tarefas podem ser realizadas utilizando-se imagens capturadas por uma
cmera. Em sistemas assim, a fim de complementar os robs no quesito robustez,
outros tipos de sensoriamento podem ser utilizados para se aumentar a gama de
aplicaes que esses robs podem executar e tambm diminuir a possibilidade de
falhas. Sendo assim, evitam-se limitaes decorrentes de situaes adversas que
podem ocorrer no ambiente durante as atividades executadas pelos robs.
Com o processamento de imagem possvel extrair informaes do mundo real
em trs dimenses (3D) a partir da projeo da imagem em duas dimenses (2D) [1,
6, 8, 9].
3.2 Tcnica Utilizada
Dentre as vrias tcnicas que podem ser utilizadas, optou-se por aquela que
melhor se adequava ao propsito deste trabalho. Sendo assim, fixou-se uma cmera a
uma altura e inclinao conhecidas em relao ao plano em que o rob executaria a
tarefa, e a partir da foi feita toda a modelagem matemtica.
importante ressaltar que foi feita a calibrao do foco da cmera a fim de se
obter as medidas com maior preciso. O processo de calibrao consistiu basicamente
na medida de um objeto, de largura conhecida, a vrias distncias da cmera, ambos
sobre uma superfcie plana. Neste caso, obteve-se duas medidas em centmetros, a
distncia da cmera ao objeto e a largura do objeto medido, e uma em pixeis, medida
manualmente com o auxlio do programa de viso computacional. De posse dessas trs
medidas foi possvel calcular o foco da cmera em pixeis pela expresso (1):
(1)
29
f =
Dd
L
Onde: f foco da cmera, em pixeis;
D distncia entre a cmera e o objeto, em centmetros;
d largura do objeto, em pixeis;
L largura do objeto, em centmetros.
Aps ajustado o foco da cmera, as imagens foram capturadas e ento
processadas pelo programa escrito na linguagem C++ utilizando algumas funes da
biblioteca OpenCV. O cdigo utilizado neste trabalho uma adaptao de uma
aplicao desenvolvida por alunos do PET da Engenharia de Computao da UFES. O
projeto citado trata de uma aplicao da viso computacional a futebol de robs cuja
orientadora a mesma do presente trabalho. As principais funcionalidades desta
aplicao incluem:
marcao da regio onde os rob executar a tarefa;
seleo das cores do rob e do alvo;
controle de velocidade, orientao e posio no espao;
seguimento de cor;
execuo de tarefas.
A imagem da Figura 13 mostra o rob e o alvo com suas cores, e a Figura 14
mostra como esses elementos so reconhecidos pelo sistema de viso. Note que na
Figura 14 as regies j esto selecionadas para o sistema de seguimento de cor.
O sistema de seguimento de cor foi desenvolvido utilizando-se algumas funes
da biblioteca OpenCV e baseado no CAMSHIFT [15]. Com essa tcnica possvel
fazer o seguimento de cor bastando que para isso seja passada a cor e o histograma de
cor da imagem. Com o histograma da cor gerado uma tabela de projeo da imagem.
Com isso, se o histograma possui uma certa distribuio de probabilidade, ento a
tabela de cor gerada tambm ter o mesmo modelo de distribuio. O CAMSHIFT
detecta o modelo de distribuio de probabilidade aplicando o Mean Shift enquanto
dinamicamente ajusta os parmetros da distribuio da cor a ser seguida. Note que o
algoritmo do CAMSHIFT segue apenas a cor selecionada. Assim, pela anlise de
30
probabilidade a seleo da cor a ser seguida ser atualizada, e servir como ponto de
partida para a localizao da cor a ser seguida quando um novo frame for capturado. A
busca no novo frame feita levando-se em considerao as proximidades da regio do
frame antigo em que o objeto com a cor a ser seguida se encontrava. Melhores
resultados do seguimento de cor utilizando o CAMSHIFT so obtidos utilizando-se o
canal HUE, do sistema de cor HSV, e o histograma da cor.
31
Figura 13: Rob e alvo com suas respectivas cores.
Figura 14: Reconhecimento de cores.
A seleo da cor a ser seguida pelo sistema feita de modo manual.
Primeiramente seleciona-se o canto esquerdo inferior e logo aps o canto direito
superior. Feito isso, registra-se os pontos e ento a regio retangular efetivamente
selecionada. No caso do rob, que neste trabalho identificado por duas cores, aps a
seleo das cores os centrides so conectados.
3.3 Consideraes Iniciais de Projeto
Para a modelagem matemtica do sistema ptico, algumas consideraes foram
feitas. Primeiramente, a cmera foi colocada na parede a uma altura e ngulo
conhecidos. A partir dessa situao, foram definidas quais seriam as transformaes
necessrias para se controlar os robs no espao 3D a partir da projeo 2D, capturada
pela cmera.
A Figura 15 ilustra o ambiente de testes com os referenciais criados. Uma vez
definidos os referenciais pode-se calcular as velocidades angular e linear do rob e
tambm sua posio de maneira bastante simplificada, j que com a mudana de
coordenadas possvel controlar o rob a partir de uma nica referncia.
32
Figura 15: Referncias do sistema ptico.
3.3.1 Modelagem Matemtica do Sistema ptico
Todo o equacionamento do sistema foi feito para que os dados capturados nos
referenciais existentes fossem considerados no referencial do rob. Com isso, o
controle do rob fica muito mais simples e tambm permite que as velocidades angular
e linear, e conseqentemente a posio do rob no espao, sejam controladas
diretamente atravs do referencial do rob.
Abaixo esto as definies matemticas do problema, mas antes disso, algumas
definies fazem-se necessrias com relao ao sistema de coordenadas adotado.
referencial do mundo ambiente de teste;
referencial da cmera ponto em que a cmera est afixada considerando sua
inclinao;
referencial do rob ponto central da linha que conecta as duas cores do rob.
Posto isso, pode-se desenvolver a parte matemtica do sistema. Para converter
um ponto representado no referencial do mundo para sua representao, ou seja,
coordenadas no referencial da cmera, tem-se:
(2)
(3)
(4)
Onde: P
C
ponto no referencial da cmera;
P
M
ponto no referencial do mundo;
R
X
matrix de rotao em torno do eixo X;
ngulo de inclinao da cmera em relao ao eixo Z.
33
R
X
() =
|
1 0 0 0
0 cos() sen() 0
0 sen() cos() 0
0 0 0 1
P
C
= R
X
() P
M
P
M
=R
X
() P
C
Substituindo as matrizes de R
X
, P
C
e P
M
encontramos:
(5)
Com isso, ao fazermos a multiplicao de matrizes acima encontramos os
pontos do mundo no referencial da cmera. :
(6)
(7)
(8)
A imagem obtida pela cmera uma projeo perspectiva do ambiente. Sendo
assim:
(9)
(10)
onde: f distncia focal em pixeis.
O modelo da cmera utilizada o pinhole. Esse modelo se baseia na passagem
dos raios luminosos por um pequeno orifcio na entrada da cmera e na sua projeo
em uma superfcie plana, como mostrado na Figura 16. As cmeras baseadas nesse
princpio so chamadas cmeras perspectivas [8]. O plano R o plano da imagem, F
paralelo ao plano R e chamado de plano focal.
34
|
X
C
Y
C
Z
C
1

C
=
|
1 0 0 0
0 cos() sen() 0
0 sen() cos() 0
0 0 0 1
|
X
M
Y
M
Z
M
1

M
X
C
= X
M
Y
C
=Y
M
cos() + Z
M
sen()
Z
C
=Y
M
sen() + Z
M
cos()
x =f
X
c
Z
C
y =f
Y
c
Z
C
Para relacionar o ponto na imagem com as coordenadas do ponto 3D no mundo
temos:
(11)
(12)
Sabendo-se que os pontos tridimensionais pertencem ao plano Y
M
= -H, no
referencial do mundo, temos:
(13)
(14)
Isolando as variveis X
M
e Z
M
, temos:
35
x =f
X
M
(Y
M
sen() + Z
M
cos())
y =f
(Y
M
cos() + Z
M
sen())
(Y
M
sen() + Z
M
cos())
x =f
X
M
(H sen() + Z
M
cos())
y =f
( Z
M
sen() H cos())
(H sen() + Z
M
cos())
Figura 16: Formao da imagem em uma cmera perspectiva.
(15)
(16)
A Figura 17 ilustra o modelo da cmera perspectiva com a projeo de um
ponto do mundo no plano da imagem. Normalmente o referencial de uma imagem
tomado como sendo o canto superior esquerdo, por isso necessria uma correo nas
coordenadas do ponto na imagem para que esse ponto seja referido ao centro de
coordenadas onde se tem (x
o
,y
o
). Contudo, neste trabalho o referencial da imagem
capturada o canto inferior esquerdo. Para isso, as relaes utilizadas nos
experimentos para encontrar x e y so descritas pelas expresses (17) e (18).
(17)
(18)
36
Z
M
= H
(f cos() + y sen())
(f sen() y cos())
X
M
=
x
f
(H sen() + Z
M
cos())
y =( y
img
y
o
)
x = x
img
x
o
Figura 17: Modelo da cmera perspectiva com projeo de ponto.
Sendo assim, a partir de x e y na imagem podemos obter X
M
, Z
M
e Y
M
, com
Y
M
= -H, e ento podemos calcular o erro de posio para o rob. Esse erro na
verdade a distncia entre a posio atual do rob e a posio para onde ele deve ir a
fim de executar a tarefa a ser realizada.
(19)
Em cada eixo teremos um = , como abaixo:
(20)
(21)
(22)
O ngulo formado entre o eixo Z e a direo em que o rob deve se locomover
pode ser calculado com a seguinte expresso:
(23)
A Figura 18 ilustra a relao do erro || e do ngulo calculado de acordo com
a tarefa a ser executada.
Note que o ngulo medido em relao ao eixo Z e indica a orientao do
rob. O ngulo tambm medido em relao ao eixo Z e utilizado para medir a
37
e
A
X
= X
d
X
A
Y
=0
A
Z
= Z
d
Z
e =Pos
desejada
Pos
atual
Figura 18: Relao do erro com a tarefa a ser executada.
=arctg (
A
X
A
Z
)
distncia angular entre o centride do rob e o ponto em que se deseja chegar.
Finalmente, o ngulo a diferena entre e , e indica quanto falta para que o rob
se alinhe no sentido do ponto alvo, ou seja, o erro angular.
De posse do valor de e do erro de posio do rob, x e z, pode-se calcular o
mdulo de , a velocidades linear e a angular.
(24)
(25)
(26)
Onde: v
Z
= v velocidade linear;
k constante de proporcionalidade;
erro angular entre o rob e o ponto alvo.
Finalmente, as expresses necessrias para o controle do rob esto
relacionadas nas expresses (27) e (28), sendo v a velocidade linear e a velocidade
angular. Foi utilizado um controlador hiperblico devido sua caracterstica de
transio suave entre valores positivos e negativos de . Essa caracterstica muito
importante para que o rob tenha movimentos mais suaves e assim evita-se erros de
posio e tambm problemas de tempo de resposta dos motores no momento da
inverso do sentido de giro. Repare que V
max
e
max
so escolhidos levando-se em
considerao resultados prticos. Neste projeto, os valores utilizados para V
max
e
max
foram 50% e 5%, respectivamente. O valor dado em porcentagem pois trata-se de
valores para o ajuste do PWM, que recebe a porcentagem da potncia para a qual o
motor deve ser ajustado.
(27)
(28)
A Figura 19 mostra um esboo da resposta da velocidade angular de acordo
com o ngulo instantneo.
38
e=
.
A
X
2
+ A
Z
2
v
Z
=e cos(0)
o=k 0
v =v
max
tanh(e) cos
2
(0)
o=o
max
tanh(0)
Como pode ser visto, a resposta desse controlador garante um movimento
bastante suave para o motor evitando-se mudanas bruscas de velocidade e tambm
mudanas bruscas de corrente nos motores.
3.3.1 Sistema de Orientao
Com o perfeito funcionamento do sistema ptico possvel utilizar as
informaes das imagens previamente capturadas e processadas para inferir a
orientao dos robs no plano de atividade.
Como o rob utilizado no equipado com sensores capazes de informar a atual
orientao, optou-se por utilizar duas cores para identific-lo. Com isso, identificar a
posio do rob bem como sua orientao no sistema torna-se bastante simples quando
comparado ao mtodo que utiliza apenas uma cor por rob. Sendo assim, uma cor
marcada como sendo a parte de trs do rob, enquanto a outra marcada como sendo a
parte da frente. Em seguida, os centrides so localizados e conectados. A partir destes
pontos, pode-se calcular a orientao do rob em relao ao eixo Z e tambm em
relao ao destino, representado por uma terceira cor.
39
Figura 19: Resposta ideal do controlador.
A expresso que avalia tanto a orientao do rob quanto o ngulo entre o eixo
Z e o ponto alvo descrita pela expresso (29). Note que Ang pode ser tanto quanto
.
(29)
Para calcular esses ngulos, foi necessrio fazer algumas consideraes para
que o ngulo encontrado estivesse sempre em relao a uma nica referncia. Com
isso, evita-se que ngulos calculados no primeiro e no terceiro quadrantes ou no
segundo e no quarto quadrantes sejam considerados iguais. Se esse cuidado no fosse
tomado, isso geraria um erro no momento em que o rob tivesse que se orientar no
sentido do alvo partindo de uma orientao aleatria.
Sendo assim, para o clculo do ngulo, utilizou-se uma srie de relaes para
identificar em que quadrante encontrava-se o vetor velocidade do rob. As relaes
levam em considerao o sinal de e de , como mostrado abaixo.
> 0 e > 0 1
o
Quadrante, Angulo = Ang
> 0 e < 0 2
o
Quadrante, Angulo = Ang +
< 0 e < 0 3
o
Quadrante, Angulo = Ang +
< 0 e > 0 4
o
Quadrante, Angulo = Ang + 2
Note que Ang o valor calculado pela expresso (29) e Angulo o valor
corrigido do ngulo para uma referncia comum e nica do sistema, considerada como
sendo o eixo Z positivo.
3.4 Captura e Processamento da Imagem
Alm da captura, no sistema de viso foram implementadas funes a fim de
encontrar o centro dos objetos marcados na imagem. Isso importante porque permite
que a manipulao do rob no ambiente seja simplificada, j que sua movimentao
baseada na posio do seu centride.
40
Ang =arctg(

)
As funes de processamento de imagem fazem parte do sistema de viso
chamado Sistema Robtico, feito em C++. A manipulao das imagens bastante
simples quando feita com o auxlio da biblioteca OpenCV da Intel. Embora todas as
funes do programa possam ser vistas na listagem do APNDICE B, algumas das
principais funes da biblioteca OpenCV relativas a este trabalho esto descritas
abaixo. So elas:
cvcamGetCamerasCount();
Retorna um inteiro com o nmero de cmeras ativas encontradas.
cvcamSetProperty(camIndex, CVCAM_PROP_ENABLE, CVCAMTRUE);
Habilita a cmera especificada em camIndex, sendo 0 o nmero da primeira.
cvcamSetProperty(camIndex, CVCAM_PROP_RENDER, CVCAMTRUE);
Habilita a digitalizao dos frames para a cmera selecionada.
cvcamSetProperty(camIndex, CVCAM_PROP_SETFORMAT, &vidFmt);
Define resoluo e quantidades de frames que sero capturados por segundo.
Para isso, vidFmt recebe uma matriz do tipo {640, 480, 30.0}.
cvcamGetProperty(camIndex, CVCAM_CAMERAPROPS, NULL);
Chama a janela de configurao dos parmetros da cmera.
cvcamInit();
Prepara a cmera com os parmetros fornecidos.
cvcamStart();
Inicia a captura da imagem.
cvcamStop();
Interrompe a captura da imagem.
cvCreateImage(cvGetSize(frame), frame->depth, 1);
Separa o canal HUE da imagem que est em frame.
Como pode ser visto acima, as funes dessa biblioteca fazem boa parte do
trabalho e por isso poupam tempo de desenvolvimento de aplicaes. Logo, essa
biblioteca acaba viabilizando aplicaes em vrias reas que envolvem processamento
de imagens.
41
4 SISTEMA COMPLETO E TAREFA PROPOSTA
4.1 Introduo
O sistema completo formado por um rob equipado com uma placa de
controle e com um conjunto de desenvolvimento da MaxStream. O rob possui
tambm duas placas coloridas em sua parte superior. Essas cores so utilizadas para
que o sistema de seguimento de cor funcione corretamente e tambm para possibilitar
a distino entre os robs ativos, caso exista mais de um, e para determinar a direo
do rob.
Nos prximos itens sero abordados os detalhes da montagem do rob, da
colocao da cmera no ambiente, da colocao das cores de identificao do rob, da
regio em que a tarefa ser executada e tambm ser definida a tarefa que se deseja
executar.
4.2 Montagem do Sistema e Detalhes de Funcionamento
A montagem da parte fsica do sistema bastante simples e apenas alguns
detalhes devem ser vistos com maior ateno. Para se evitar problemas, deve-se
remover todos os obstculos no plano em que o rob se movimenta. Isso deve ser feito
porque nem o rob e nem o sistema de seguimento de core capaz de detectar
obstculos. Outro aspecto levado em considerao a possibilidade de existirem
objetos que pudem ter suas cores confundidas com as cores dos robs, fato que poderia
fazer com que o sistema de seguimento de cores perdesse os robs.
Em relao cmera, dois aspectos precisam ser vistos com muita ateno.
Primeiro, o foco da cmera deve ser ajustado, tal como explicado no item 3.2, para que
os clculos de posio sejam feitos corretamente ao converter coordenadas medidas
em pixeis para coordenadas no referencial do mundo, em centmetros. Segundo, a
cmera deve ser afixada a uma altura H conhecida e com uma inclinao tambm
conhecida, j que o sistema ptico leva em considerao todas essas variveis para
estimar a correta posio do rob.
42
Todo o controle do sistema feito pelo computador com dados do sistema
ptico. No incio do processo necessrio selecionar as regies a serem consideradas
pelo sistema de seguimento de cor. Com isso, as cores do rob e tambm a cor do
ponto alvo devem ser selecionadas para que o sistema possa ento considerar essas
cores no momento da execuo da tarefa. Para se evitar problemas no sistema de
deteco e seguimento de cor existem dois cuidados bsicos que precisam ser
tomados. O primeiro deles em relao s cores, pois no recomendvel utilizar
cores muito semelhantes. O segundo em relao aproximao dos corpos coloridos,
que no devem se aproximar muito para evitar que o sistema ptico junte as cores e
passe ento a considerar duas ou mais regies como sendo apenas uma.
Em relao ao funcionamento do sistema, o sistema ptico adquire as imagens
do ambiente, essas imagens so processadas e ento o sistema de seguimento de cor
cuida da movimentao do rob no ambiente de acordo com o objetivo da tarefa.
Nesse caso, os dados relevantes ao controle do rob, velocidade linear e angular, so
transmitidos pelo computador via porta serial, utilizando-se tambm um mdulo XBee
para enviar mensagens em broadcast. Sendo assim, caso houvessem mais robs no
sistema, todos receberiam as mesmas informaes, mas o programa do MSP430 faz a
checagem para saber qual deve executar os comandos recebidos. Isso possvel
porque quando um comando enviado pelo PC ele vai codificado com a indicao de
qual rob deve execut-lo, e por outro lado, o programa do MSP430 checa se o cdigo
recebido o mesmo do rob. Se essa informao coincidir, o rob executa os
comandos.
A Figura 20 mostra o ambiente de teste e um rob com suas cores de
identificao. Nessa figura pode-se ver tambm o ponto alvo de chegada para o rob,
em verde sobre a mesa. Esse ponto alvo representado por um objeto colorido, visto
que o sistema considera que o ponto alvo poderia ser na verdade um outro rob ou
algo que deva ser perseguido, como ocorre no projeto desenvolvido pelo PET da
Engenharia de Computao, em que os robs devem perseguir uma bola colorida.
43
4.3 Tarefa Proposta
A tarefa proposta tem como objetivo testar as funcionalidades do sistema e no
necessariamente visa a realizao de procedimentos. Testes mais elaborados podem
ser criados e realizados em ambientes e situaes mais realistas como aplicaes em
cho-de-fbrica ou at mesmo aplicaes em que os robs podem assumir papis de
guardas ou observadores mantendo-se sempre atentos a um determinado evento.
Para este projeto, a tarefa a ser realizada considera a colocao de um alvo no
ambiente para que o rob o alcance. Para isso, o alvo identificado com uma
marcao colorida e o rob com duas outras marcaes que indicam sua parte frontal
e traseira.
Na tarefa a ser executada, o procedimento inicial bastante simples. O
ambiente de testes ser capturado pela cmera e a rea que o programa deve considerar
para o monitoramento ser previamente selecionada na imagem como sendo o campo
de atividade. Feito isso, um rob ser colocado nesse ambiente de teste e ento, as
44
Figura 20: Ambiente de teste.
cores dos rob sero tambm selecionadas e adicionadas ao sistema de seguimento de
cor. O prximo passo a marcao do alvo, isto , o ponto em que os rob deve
chegar ao final da tarefa.
Para fins de simplificao, a tarefa proposta considera a reorientao dos robs
na direo e sentido necessrio para que o alvo seja atingido. importante lembrar que
tanto os rob quanto o alvo so considerados como sendo corpos pontuais
independente de suas dimenses fsicas ou da rea selecionada na imagem.
A realizao de uma tarefa como essa abre caminhos para muitas possibilidades
de aplicaes. Com isso, embora parea simples, essa tarefa permite posicionar robs
frente-a-frente, empurrar caixas, carregar objetos de um ponto a outro, seguir objetos,
reconhecer marcaes e executar tarefas diversas individualmente ou em equipes de
robs.
45
5 EXPERIMENTO
5.1 Introduo
A fase de testes deste trabalho se mostrou extremamente importante para o
conhecimentos dos problemas, limitaes, condies apropriadas aos testes, e tambm
para reavaliar a possibilidade de implantar um sistema como esse para aplicaes
reais.
5.2 Teste e Anlise dos Resultados
O que se esperava como resultado era que pelo processamento de imagem o
rob se dirigisse ao alvo aps receber as velocidades linear e angular, resultado do
processamento de imagem baseado no seguimento de cor de cor. Eram esperados
alguns problemas devido iluminao do ambiente. Com relao ao XBee, no eram
esperados problemas visto que trata-se de um dispositivo bastante simples de usar at
mesmo quando ajustado com as configuraes padro de fbrica. Esperava-se tambm
alguns problemas decorrentes da projeo da imagem, j que existem algumas
imprecises do sistema fsico quando comparado modelagem matemtica. As
principais imprecises foram notadas quando o rob se afastava muito da cmera.
Nessa condio, a orientao do rob no foi realizada de maneira muito correta, e
apesar do rob chegar ao ponto alvo, no o fazia com a orientao esperada.
Aps iniciados os testes ocorreram uma srie de problemas. O primeiro deles
foi devido origem da imagem capturada pela webcam, que foge dos padres quando
comparada s outras cmeras utilizadas em [6, 8, 13, 14]. De maneira geral, a origem
da imagem capturada o ponto esquerdo superior, no entanto, para a webcam utilizada
neste trabalho a origem das imagens capturadas o ponto esquerdo inferior. Com isso,
uma srie de testes e medidas de distncias foram necessrios at que o programa de
seguimento de cor estivesse completamente adaptado a este projeto. O segundo
problema ocorreu devido a uma caracterstica da webcam utilizada. Essa cmera ajusta
automaticamente o brilho dependendo da iluminao do ambiente. Isso trouxe srios
46
problemas aos testes j que o procedimento inicial do processamento de imagem
considera a captura de um frame, a converso para HSV, a separao do canal HUE e
ento a subtrao do fundo para que as cores de identificao do rob e do alvo
possam ser detectadas. Quando a iluminao variava, por menos que fosse, a cmera
reajustava o brilho automaticamente e ento o fundo no era mais o mesmo. Isso fazia
com que aparecessem diversas manchas na imagem. Por isso, muito importante fazer
os testes em superfcie fosca e utilizar cores foscas para o rob e para o alvo. Com
todos esses rudos, facilmente o sistema de seguimento de cor perdia os objetos ou
mesmo unia duas ou mais cores como se fossem apenas uma, resultando em uma falha
total do sistema. Outro problema encontrado, diz respeito configurao da cmera no
ambiente. Como a cmera capturava o ambiente a uma inclinao de -30 com a
horizontal, e a mesa de testes ficava a cerca de 130 cm abaixo da cmera e a uma
distncia horizontal de 180 cm, quando o rob se afastava muito da cmera as regies
coloridas se tornavam muito pequenas, embora a rea da cor selecionada no fosse
redimensionada. Isso fazia com que as regies se aproximassem muito aumentando as
chances de que as reas inicialmente selecionadas se fundissem. Devido distncia,
tambm foi observado que quando as regies coloridas se tornavam muito pequenas o
sistema de seguimento de cor perdia a cor com facilidade, pois durante o movimento
do rob muitos rudos na imagem eram gerados e se o rob se aproximasse desses
rudos o sistema poderia confundi-los com a cor que estava sendo acompanhada,
resultando na falha do teste.
Nas Figura 21 e 22 pode-se ver as imagens do sistema em funcionamento
durante a execuo de uma tarefa. Note que na Figura 21 as cores haviam apenas sido
selecionadas e o rob ainda estava em repouso. Na Figura 22 o rob estava se
locomovendo na direo do alvo. Repare que neste ltimo caso, muitos rudos
surgiram na imagem e a tarefa poderia falhar com relativa facilidade caso o rob
transitasse em regies com muito rudo.
A respeito dos rudos gerados na imagem durante a execuo da tarefa, algumas
precaues podem ser tomadas a fim de minimizar as chances do sistema de
seguimento de cor falhar. So elas:
47
a estrutura do rob e a superfcie em que ele se movimenta devem ser foscas;
deve-se evitar que ocorra variao de luminosidade no ambiente;
vibraes da superfcie em que o rob se movimenta e de sua prpria estrutura
devem ser evitadas ou minimizadas;
a distncia entre o rob e a cmera no pode ser muito elevada, pois a chance
do sistema de seguimento de cor perder as cores ou mesmo perder a preciso ao
inferir a orientao do rob aumenta significativamente com a distncia;
os testes mostraram no ser recomendvel o uso de webcam em sistemas como
este, pois estas fazem ajuste automtico de brilho com a mnima variao de
luminosidade, e nesse momento muitos rudos so inseridos no sistema.
Com base nos itens descritos acima e levando-se em considerao as condies
em que o teste da Figura 22 foi feito, pode-se atribuir os rudos capturados nessa
imagem vibrao da estrutura do rob, vibrao da mesa em que ele se
movimentava, e tambm variao de luminosidade no momento do teste.
Apesar dos rudos gerados, a maioria dos testes foi bem sucedida. Ocorreram
problemas apenas nos testes em que os robs estavam muito distantes da cmera, e
naqueles em que os robs transitavam nas regies da imagem com excessivos rudos
provocados por sobras e por variaes intensas de luminosidade. Falharam tambm os
testes em que as velocidades linear e angular do rob estavam ajustadas para valores
muito elevados. Com isso, atravs de experimentos chegou-se a valores de V
max
e
max
iguais a 50% e 5%, respectivamente.
48
49
Figura 21: Cores selecionadas com o sistema em repouso.
Figura 22: Cores selecionadas e rudos gerados com o sistema em
funcionamento.
6 CONCLUSO
O sistema elaborado neste projeto tem como intuito principal a criao de uma
aplicao capaz de movimentar robs em um ambiente utilizando-se tcnicas de viso
computacional e comunicao sem fio pelo padro 802.15.4, ZigBee. tambm de
interesse que este sistema seja aplicvel a tarefas em que os robs envolvidos possam
trabalhar em cooperao.
Apesar de no ter sido feita uma aplicao envolvendo mais de um rob, o
sistema foi preparado para tornar isso possvel. No entanto, uma aplicao com mais
robs exigiria a criao de uma lgica de execuo de tarefas capaz de control-los de
modo organizado de acordo com a tarefa a ser executada. Assim, seriam necessrias
vrias marcaes coloridas no ambiente e tarefas personalizadas para quantidades
diferentes de robs, isto , seria necessrio a criao de uma estratgia mais complexa
de execuo de tarefas.
O padro ZigBee mostrou-se bastante interessante tanto pela simplicidade de
utilizao quando pelas caractersticas tcnicas que apresenta. A comunicao entre os
dispositivos feita de maneira bastante simplificada e eficiente. Apesar de que as
instrues do XBee no tenham sido exploradas a fundo, pelo conjunto de instrues
que apresenta pode-se ter uma idia da versatilidade deste dispositivo. Aplicaes
muito complexas podem ser desenvolvidas utilizando-se algumas poucas funes
como checagem de nvel de bateria, nvel de sinal, captura de informaes de outros
dispositivos no campo de alcance e endereamento de informaes a dispositivos
especficos ou em broadcast. Alm disso, o ZigBee mostra-se bastante interessante
com relao s tcnicas de modulao que utiliza e tambm em relao segurana
dos dados que trafegam na rede.
Embora os resultados tenham sido satisfatrios para este projeto, sistemas como
esse precisam ser muito bem desenvolvidos e melhorados para que influncias
externas no comprometam tanto seu funcionamento. Com este trabalho conclui-se
que o sucesso do sistema depende de muitos quesitos que vo desde a maneira como a
parte de software desenvolvida at o tipo de equipamento que se utiliza. Deve-se
tambm providenciar filtros para imagens capazes de reduzir os rudos e ento
50
aumentar a eficincia e confiabilidade do sistema como um todo. Isso de extrema
importncia, pois nenhum sistema funciona em condies de isolamento total e falhas
podem ocorrer quando menos se espera, e por isso, o sistema deve estar preparado para
lidar com elas.
6.1 Trabalhos Futuros
Muitas melhorias so planejadas para trabalhos futuros. O atual trabalho ainda
no considera sistemas de sensoriamento dos robs e nem mesmo dispositivos que
possibilitem giros calculados e precisos. O sistema de seguimento de cor ainda um
pouco falho e isso pode fazer com que o acompanhamento dos robs seja prejudicado
dependendo de suas velocidades ou mesmo da mudana de intensidade luminosa no
ambiente, j que a webcam utilizada faz ajustes automticos diminuindo ou
aumentando o brilho da imagem.
Para trabalhos futuros, alm da implementao de sistemas mais robustos
incluindo sensoriamento e melhorias no sistema de seguimento de cor, planeja-se
tambm um sistema de reconhecimento automtico dos robs ativos na rea de alcance
do XBee bem como um sistema capaz de detectar as cores do robs encontrados sem
que haja necessidade de interveno humana, tal como feito no presente trabalho.
Outro objetivo para trabalhos futuros fazer com que os robs sempre cheguem ao
alvo com uma orientao especfica em relao ao objeto marcado como alvo,
independente das condies iniciais do sistema.
A respeito do sistema de viso como um todo, tambm desejvel que as
funes de manipulao de imagens possam ser aceleradas, visto que o atual sistema
exige uma performance considervel do computador. Isso ocorre em parte pelo fato de
que algumas das funes do sistema apresentado nesse projeto poderiam ter sido
melhor desenvolvidas para otimiz-lo. A biblioteca OpenCV oferece muitos recursos
poderosos que se bem aplicados podem contribuir para a criao de sistemas cada vez
mais robustos e mais inteligentes.
51
APNDICE A
Para o controle do MSP430 foram feitas algumas adaptaes no cdigo
desenvolvido em [14]. As explicaes podem ser encontradas em forma de
comentrios no corpo do programa.
A principal adaptao feita diz respeito retirada do controlador integrador que
est presente no programa original. Isso foi feito porque todo o controle dos robs
passou a ser realizado pelo programa de viso computacional a fim de reduzir a carga
de processamento de cada rob.
Abaixo, segue a listagem completa do cdigo em C.
Arquivo: pwm2_higor.c
#include <msp430x14x.h>
#include <intrinsics.h>
#define L 19 //distancia entre as rodas, em cm
#define PWM_PERIOD 400 //60000 // 50
#define MOTOR_LEFT 0 //endereco do motor esquerdo
#define MOTOR_RIGHT 1 //endereco do motor direito
#define MAX_VAL 100 //maximo valor para velocidades
#define MIN_VAL -100 //minimo valor para velocidades
#define FRAME_SIZE 5 //quantidade de bytes para receber/enviar
#define SEGUIDOR 0 //numero do seguidor (deve ser mudado para o
//programa de cada seguidor)
#define FROM_SEG 12 //informacao vinda do modulo seguidor (robo),
//apenas confirmacao
#define FROM_LID 13 //informacao vinda do lider (PC)
int vel_linear = 0; //velocidade linear desejada
int vel_angular = 0; //velocidade angular desejada
int vel_direita = 0;
int vel_esquerda = 0;
int power[2] = {0,0}; //power guarda os valores para ajustar as
//velocidade dos motores direito e esquerdo
short int index_rx = 0; //index_rx para o buffer_rx
short int buffer_tx = 0; //armazena o byte que sera enviado ao PC
short int buffer_rx[FRAME_SIZE] = { 0, 0, 0, 0, 0 };
//armazena os bytes recebidos do PC
//1 -> sinal da velocidade linear
//2 -> modulo da velocidade linear
//3 -> sinal da velocidade angular
//4 -> modulo da velocidade angular
//5 -> seguidor/comando
52
//----------------- CONFERE E AJUSTA VELOCIDADES MAXIMAS --------------//
int limit_range( float value )
{
if ( value < MIN_VAL )
return MIN_VAL;
else if ( value > MAX_VAL )
return MAX_VAL;
else
return value;
}
//-------------------- AJUSTA A POTENCIA DOS MOTORES ------------------//
void alter_power(short int motor_index)
//ajusta cada motor com o valor de PWM calculado para cada roda
{
if (motor_index == MOTOR_RIGHT)
{
power[ motor_index ] = limit_range(vel_direita);

if (power[motor_index] < 0)
{
TBCCR3 = 0;
TBCCR4 = (int)(4 * (-power[motor_index]));
}
else
{
TBCCR3 = (int)(4 * power[ motor_index]);
TBCCR4 = 0;
}
}
else if (motor_index == MOTOR_LEFT)
{
power[ motor_index ] = limit_range(vel_esquerda);

if (power[motor_index] < 0)
{
TBCCR1 = (int)(4 * (-power[motor_index]));
TBCCR2 = 0;
}
else
{
TBCCR1 = 0;
TBCCR2 = (int)(4 * power[motor_index]);
}
}
}
//---------------------- ATUALIZA AS VELOCIDADES ----------------------//
void update_velocities(void)
{
// velocidade linear
vel_linear = (short int)buffer_rx[1];
// velocidade angular
vel_angular = (short int)buffer_rx[3];

if (buffer_rx[0] == 1)
53
vel_linear = -vel_linear;

if (buffer_rx[2] == 1)
vel_angular = -vel_angular;

// separa as velocidades de cada roda a partir da
//velocidade angular e linear
vel_direita = vel_linear + (vel_angular * L)/ 2;
vel_esquerda = vel_linear - (vel_angular * L)/ 2;
}
//---------------------- CONTROLE DE VELOCIDADES ----------------------//
// Procedimento principal
void speed_control( void )
//implementa o loop de controle
{
int testeBuffer = 0;
while(1)
{
if ((buffer_rx[4] == SEGUIDOR))
{
update_velocities();
alter_power(MOTOR_LEFT);
alter_power(MOTOR_RIGHT);
testeBuffer = 0;
}
// FROM_SEG = 12, FROM_LID = 13
else if ((buffer_rx[4] == FROM_LID) &&
(buffer_rx[3] == SEGUIDOR) && (testeBuffer == 0))
{
buffer_tx = SEGUIDOR;
U0TXBUF = buffer_tx;
testeBuffer = 1; // controle de execucao
}
}
}
//--------------------- INICIA COMUNICACAO SERIAL ---------------------//
void initCOM( void ) {
ME1 = URXE0 + UTXE0;
U0CTL = 0;
U0CTL = CHAR + SWRST; // Configura para bit de paridade 8 bits
//recebidos e enderecamento por inatividade de linha
U0TCTL = SSEL1 + SSEL0; // configura o clock da USART para o SMCLK
//que deve ser de 1MHz
//U0RCTL = 0; // configura a interrupcao de caracteres
U0MCTL = 0x92; // configura a velocidade de envio para 9600 bps
U0BR0 = 0x41;
U0BR1 = 0x03;
U0CTL = U0CTL & 0xfe ;
IE1 = URXIE0 + UTXIE0;
}
//---------------------------- INICIA PWM ----------------------------//
void initPWM( void )
{
54
// configuracao do Timer_B para o controle do PWM
TBCTL = TBSSEL_2 + ID_0 + MC_1;
TBCCR0 = PWM_PERIOD - 1;// Clock Frequency: 8000000/(ID_X *
//PWM_PERIOD)
TBCCTL1 = OUTMOD_7; // TBCCR1 in output mode: 7 - reset/set
TBCCR1 = 0; // sem sinal inicial
TBCCR2 = 0; // sem sinal inicial
TBCCR3 = 0;
TBCCR4 = 0;
}
//-------------------------- ROTINA PRINCIPAL -------------------------//
int main(void)
{
unsigned int i;
// Inicializacoes
WDTCTL = WDTPW + WDTHOLD; // para o Watchdog Timer
// Turning XT1 (32kHz) on
_BIC_SR (OSCOFF); // liga XT1
BCSCTL1 &= ~XTS; // modo LF
for (i = 0xFFFF; i > 0; i--); // tempo para ajuste do oscilador
// XT1 is on
// Turning XT2 (8MHz) on
BCSCTL1 &= ~XT2OFF; // liga XT2
do
{
IFG1 &= ~OFIFG; // limpa o flag OSCFault
for (i = 0xFF; i > 0; i--); // tempo para ajuste do flag
}
while ((IFG1 & OFIFG) != 0); // o flag OSCFault continua ajustado?
// XT2 is on
BCSCTL2 |= SELM_2 + DIVM_0 + // XT2 e a fonte para MCLK,
// divisor de MCLK e 1
SELS + DIVS_0; // DCO e a fonte para SMCLK,
// divisor de SMCLK e 1
BCSCTL1 |= DIVA_0; // divisor para ACLK e 1
// Nesse ponto nos temos a seguinte configuracao de clock:
// MCLK e 8 MHz (de XT2)
// SMCLK e 8 MHz (de XT2)
// ACLK e 32 kHz (de XT1)
// Ajustes para pinos de E/S
// P1
P1DIR = 0xFF; // nao utilizado (NC)
P1SEL = 0x00; // todos os pinos como E/S
// P2
55
// P3
P3DIR = 0xDB; //
P3SEL = 0x3C; //
// P4
P4DIR = 0xFF; // saidas
P4SEL = 0x1E; // P4.1 a P4.4 como TB1-4, outros como E/S
// P5
// P6

initCOM();
initPWM();

_EINT(); // habilita interrupcoes
speed_control(); // rotina principal

return 0;
}
//--------------------- TRATAMENTO DE INTERRUPCAO ---------------------//
// Tratamento de interrupcoes para recebimento de dados pela USART0
#pragma vector = USART0RX_VECTOR
__interrupt void usart0_rx(void)
{
buffer_rx[index_rx] = U0RXBUF; // armazena na posicao 0 primeiro

if (++index_rx == FRAME_SIZE)
{
index_rx = 0;
}
}
// Tratamento de interrupcoes para envio de dados pela USART0
#pragma vector = USART0TX_VECTOR
__interrupt void usart0_tx(void)
{
/* if (index_tx < FRAME_SIZE)
{
U0TXBUF = buffer_tx[index_tx]; // envia a posicao 0 primeiro
index_tx++;
}
else
{
index_tx = FRAME_SIZE; // FRAME_SIZE = 5
}
*/
}
56
APNDICE B
O programa utilizado para controle dos motores e seguimento de cor foi
baseado no trabalho desenvolvido pelo PET da Engenharia de Computao da UFES.
No entanto, o trabalho original considera a colocao de uma cmera sobre a regio
em que o futebol de robs praticado, enquanto que neste trabalho a cmera foi
colocada a uma altura, distncia e ngulo com a horizontal conhecidos. Com isso,
passou-se a trabalhar com imagens projetivas e por isso algumas adaptaes se fizeram
necessrias.
Na lista abaixo esto todos os arquivos utilizados pelo programa completo com
a indicao se passaram ou no por alteraes.
Referncia Nome do arquivo Modificao
1 RobotSystem.cpp no
2 SistemaRobotico.h no
3 SistemaRobotico.cpp no
4 ComSerial.h sim
5 ComSerial.cpp sim
6 Camera.h no
7 Camera.cpp no
8 CoordSystem.h no
9 CoordSystem.cpp sim
10 defines.h no
11 DadosVisao.h no
12 DadosVisao.cpp no
13 Tempo.h no
14 Tempo.cpp no
15 BasicProcessor.h no
16 BasicProcessor.cpp no
17 SimpleTracker.h no
18 SimpleTracker.cpp no
19 DoubleTracker.h no
20 DoubleTracker.cpp no
21 TeamTracker.h no
22 TeamTracker.cpp no
23 SistemaVisao.h sim
24 SistemaVisao.cpp sim
57
A seguir, so listados os arquivos alterados e suas respectivas mudanas.
Repare que a numerao na frente de cada arquivo listado segue a referncia acima.
4. ComSerial.h
A este arquivo foi adicionada a funo read() e a funo setBufferInfoSolicita().
A primeira funo para possibilitar a leitura do buffer quando o MSP430 envia dados
informando o cdigo de identificao do rob. A segunda, ajusta o buffer a ser enviado
com valores que o MSP430 interpreta como sendo a solicitao do cdigo interno do
rob. Embora este cdigo esteja completamente funcional, no foi implementado no
programa do MSP430 uma funo capaz de utiliz-lo.
#include "windows.h"
#define COMM_BUFFER_SIZE 5
#define MIN_VAL -100 // valor em porcentagem
#define MAX_VAL 100

#ifndef COMSERIAL_H // para evitar problema de "'class' type redefinition"
#define COMSERIAL_H
class ComSerial
{
DWORD bytes_2_write;
DWORD bytes_2_read;
DWORD bytes_written;
DWORD bytes_read;
HANDLE com1;
DCB dcb;
DCB previous_dcb;
int limit_range(int);
unsigned char ModV; // valores que serao enviados ao microcontrolador
unsigned char SinV;
unsigned char ModW;
unsigned char SinW;
float param; // numero a ser convertido
float fracpart; // parte fracionaria do numero
float intpart; // parte inteira do numero
public:
ComSerial();
~ComSerial();
unsigned char BufferEnvia[COMM_BUFFER_SIZE]; // dados a ser enviado
unsigned char BufferRecebe[1];
unsigned char buffer_recebido[10];
58
int open(); //Abre e configura a porta Com1
int close(); //Fecha a porta e reseta para valores iniciais
void setBuffer(float v,float w, unsigned char s);
void setBufferInfoSolicita(unsigned char s);
void getBuffer(); // le a porta serial
int write(); //escreve o buffer na porta
int read(); //le o buffer da porta
public:
friend class SimpleTracker;
friend class DoubleTracker;
};
#endif
5. ComSerial.cpp
Nesse arquivo, foi implementada a funo de leitura, read(), e a funo de
ajuste do buffer, setBufferInfoSolicita().
#include <math.h>
#include "ComSerial.h"
#include <windows.h>
#include <iostream>
using namespace std;
ComSerial::ComSerial() // construtor
{
bytes_2_write = COMM_BUFFER_SIZE;
bytes_2_read = 1;
bytes_written = 0;
bytes_read = 0;
BufferEnvia[0] = 0;
BufferEnvia[1] = 0;
BufferEnvia[2] = 0;
BufferEnvia[3] = 0;
BufferEnvia[4] = 0;
BufferRecebe[0] = 0;
}
ComSerial::~ComSerial() // destrutor
{
}
int ComSerial::limit_range(int value)
{
if ( value < MIN_VAL )
return MIN_VAL;
else if ( value > MAX_VAL )
return MAX_VAL;
else
return value;
}
int ComSerial::open()
59
{
TCHAR *pcCommPort = TEXT("COM1");
com1 = CreateFile(pcCommPort, GENERIC_READ | GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, 0, NULL);
if (com1 == INVALID_HANDLE_VALUE) {
cout << "\n\tDesculpe! Nao posso abrir a porta COM1.";
switch( GetLastError() )
{
case ERROR_ACCESS_DENIED:
cout << "\n\tRazao: Existe alguem utilizando a
porta. Saindo...";
return -1;

case ERROR_FILE_NOT_FOUND:
cout << "\n\tRazao: Essa porta nao existe!
Saindo...";
return -1;

default:
cout << "\n\tRazao: Nao sei! Saindo...";
return -1;
}
}

DCB nulo = {0};
dcb = nulo;
previous_dcb = nulo;

dcb.DCBlength = sizeof(DCB);
previous_dcb.DCBlength = sizeof(DCB);

if(!GetCommState(com1, &previous_dcb))
{
cout << "\n\tFalha ao receber o estado da COM1. Saindo...";
CloseHandle( com1 );
return -1;
}

dcb.BaudRate = CBR_9600;
dcb.ByteSize = 8;
dcb.Parity = NOPARITY;
dcb.StopBits = ONESTOPBIT;

if( !SetCommState( com1, &dcb ) )
{
cout << "\n\tFalha ao ajustar o estado de COM1. Saindo...";
CloseHandle( com1 );
return -1;
}
return 0;
}
int ComSerial::write()
{
if(!WriteFile(com1, &BufferEnvia, bytes_2_write, &bytes_written, 0))
{
60
cout << "\n\tNao posso escrever na porta COM1...";
return -1;
}
return 0;
}
int ComSerial::read()
{
if(!ReadFile(com1, &BufferRecebe, bytes_2_read, &bytes_read, 0))
{
cout << "\n\tNao posso ler da porta COM1...";
return -1;
}
bytes_read = 0;
return 0;
}
int ComSerial::close()
{
if(!SetCommState(com1, &previous_dcb))
{
cout << "\tFalha ao resetar o estado da porta COM1.\n";
return -1;
}

CloseHandle(com1);
return 0;
}
void ComSerial::setBuffer(float v, float w, unsigned char s)
{
int vel_v;
int vel_w;
param = v;
fracpart = modf(param , &intpart);
vel_v = int(intpart);
vel_v = limit_range(vel_v);
//w = limit_range(w);
param = w;
fracpart = modf(param , &intpart);
vel_w = int(intpart);
vel_w = limit_range(vel_w);
// Separa o sinal e o modulo
// velocidade linear
if (vel_v >= 0)
{
SinV = unsigned char(0); // valor positivo
}
else
{
SinV = unsigned char(1); // valor negativo
}
ModV = unsigned char(abs(vel_v));
// velocidade angular
if (vel_w >= 0)
61
{
SinW = unsigned char(0);
}
else
{
SinW = unsigned char(1);
}
ModW = unsigned char(abs(vel_w));
// coloca os dados no buffer para serem enviados
BufferEnvia[0] = SinV;
BufferEnvia[1] = ModV;
BufferEnvia[2] = SinW;
BufferEnvia[3] = ModW;
BufferEnvia[4] = s; // definir as estrategias de controle da
// tafera por robo

}
void ComSerial::setBufferInfoSolicita(unsigned char s)
{
// coloca os dados no buffer para solicitar informacoes
BufferEnvia[0] = 0;
BufferEnvia[1] = 0;
BufferEnvia[2] = 0;
BufferEnvia[3] = s;
BufferEnvia[4] = 13; // informa que o pedido vem do lider
}
void ComSerial::getBuffer()
{
read();
}
9. CoordSystem.cpp
Neste arquivo foi mudada a funo transform() para que os pontos capturados
da imagem fossem corrigidos adequadamente em relao ao centro da imagem
capturada pela cmera. Neste ponto deve-se levar em considerao que para a webcam
utilizada a origem do sistema o ponto inferior esquerdo.

#include "CoordSystem.h"
#include <math.h>
#include <stdio.h>
Vec2f::Vec2f() // construtor
{
x=0;
y=0;
}
Vec2f::Vec2f(float a, float b)
{
x=a;
y=b;
62
}
Vec2f::Vec2f(CvPoint P)
{
x = P.x;
y = P.y;
}
Vec2f Vec2f::operator=(const Vec2f& V)
{
x = V.x;
y = V.y;
return *this;
}
Vec2f Vec2f::operator+(const Vec2f& V2)
{
Vec2f result; // result e uma variavel do tipo Vec2f
result.x = x + V2.x; // Atencao: result.x != x != V2.x
result.y = y + V2.y;

return result;
}
Vec2f Vec2f::operator-(const Vec2f& V2)
{
Vec2f result;
result.x = x - V2.x;
result.y = y - V2.y;
return result;
}
float Vec2f::operator*(const Vec2f& V)
{
return x*V.x + y*V.y;
}
Vec2f Vec2f::operator/(const float alfa)
{
Vec2f result;
result.x = x/alfa;
result.y = y/alfa;
return result;
}
void Vec2f::normaliza(float v)
{
float alfa = x*x+y*y;
x *= v/alfa;
y *= v/alfa;
}
float Vec2f::distance(Vec2f& V)
{
return sqrt(pow((x-V.x),2) + pow((y-V.y),2)); // pow(7,3) = 7^3
}
63
float Vec2f::angle(Vec2f& V)
{
static float pi = 3.141592654;

float deltaX, deltaY, ang;
deltaX = V.x - x;
deltaY = V.y - y;
ang = atan(deltaY/deltaX);
if(deltaX > 0)
if(deltaY < 0)
return ang + 2*pi;
else
return ang;
else
return ang + pi;
}
CoordSystem::CoordSystem(Vec2f ref[4])
{
Vec2f aux1, aux2;
float aux3, aux4;
/*Calculo de u1*/
aux1 = (ref[1]-ref[0]);
aux2 = (ref[3]-ref[2]);
u1 = (aux1 + aux2)/2;
u1.normaliza(120);

/*Calculo do angulo*/
aux3 = atan(fabs(aux1.y)/fabs(aux1.x));
aux4 = atan(fabs(aux2.y)/fabs(aux2.x));
beta = (aux3 + aux4)/2;
/*Calculo de u2*/
aux1 = ref[2]-ref[0];
aux2 = ref[3]-ref[1];
u2 = (aux1 + aux2)/2;
u2.normaliza(70);

/*Calculo do centro*/
Centro = (ref[0]+ref[1]+ref[2]+ref[3])/4;
}
Vec2f CoordSystem::transform(Vec2f &ponto)
{
Vec2f aux;

aux.x = ponto.x - Centro.x;
aux.y = -(ponto.y - Centro.y);

return aux;
}
64
23. SistemaVisao.h
A aplicao principal foi desenvolvida utilizando-se os arquivos de
SistemaVisao. Aqui foram inseridas novas funes, novas variveis e novas definies
para a aplicao. Foram inseridas informaes sobre a posio da cmera em relao
mesa, onde os testes foram feitos, e passou-se a comandar a porta serial por esse
arquivo. As novas funes inseridas foram: calcTransf(), calcMove() e calcAngulo().
#pragma once
#include "TeamTracker.h"
#include "CoordSystem.h"
#include "BasicProcessor.h"
#include "Tempo.h"
#include "../Controle/ComSerial.h"
// Defininicao de constantes
#define FOCO 767 // Foco da cmera em pixels, encontrado
// com experimento
#define ALTURA_ROBO 115 // Altura entre a camera e a parte superior
// do robo
#define ALTURA_MESA 130
#define FI -0.5236 // Inclinacao da camera em relacao ao
// plano do robo (float), 30 = 0.5236
class SistemaVisao
{
float psi; // angulo entre eixo Z e alvo
float alfa; // angulo da orientacao do robo em relacao a Z
float teta; // teta = psi - alfa
float v; // velociade linear
float w; // velocidade angular (giro)
float x[10]; // ponto do robo (3D) projetado na imagem (2D)
float y[10];
float Xc; // pontos da camera
float Yc;
float Zc;
float Xm; // pontos do robo no referencial do mundo
float Zm;
float Xd; // ponto em que se deseja chegar
float Zd;
float V_MAX;
float W_MAX;
float Xmundo; // usados para conversoes
float Zmundo;
float ModE; // modulo do erro
float xDest; // guarda posicao do alvo em pixels
float yDest;
int infoRobos[10][3]; // guarda o nome do robo e suas velocidades
// linear e angular
char statusRobo[10]; // informa se o robo esta ativo ou nao
protected:
BasicProcessor* basicProc;
CoordSystem *coordSys;
65
SimpleTracker* opponents[MAXP];
SimpleTracker* target; // ponto alvo em que os robos devem chegar
DoubleTracker* players[MAXP];
int NO, NP; /*Numero de Opponents e Players inseridos*/
TeamTracker *teamTr;
ComSerial* com;
int addRobotsMode;
Vec2f fieldRef[4];
Vec2f mouseClkPos;
CvRect window;
CvRect primaryArea, secondaryArea;
public:
SistemaVisao(void);
public:
~SistemaVisao(void);
public:
DadosVisao* processaFrame(IplImage* F); //Processa frame e retorna
//informacoes dos robos
void calibra();
Camera* iniciaCamera(VideoProcessor *VP);
protected:
static void mouseCallback(int events,int x,int y,
int flags,void* param);
void printFieldMenu();
void calcPositions();
void calibCoordS();
void calcBackGnd();
void addRobots();
void calcTransf(float,float,int);
void calcMove(int,float,int);
float calcAngulo(float ExT1, float EyT1);
public:
friend class SimpleTracker;
friend class DoubleTracker;
};
24. SistemaVisao.cpp
As mudanas citadas em SistemaVisao.h foram implementadas neste arquivo.
Aqui so descritas as novas funes e tambm principais adaptaes feitas em
addRobots().
A nova funo calcTransf() responsvel por fazer a transformao das
coordenadas da imagem, em pixels, para as coordenadas do mundo, em centmetros.
A funo calcMove() cuida da movimentao do rob e faz o controle de
execuo calculando e enviando as velocidades linear e angular atualizadas. Essa
66
funo tambm envia o comando de parada ao rob quando este se encontra
distncia definida em DIST_SEGURA.
A ltima, calcAngulo(), calcula o ngulo sempre tomando como referncia o
eixo Z positivo. Essa funo utilizada para o clculo de , ngulo entre o centride
do rob e o ponto alvo, e de , ngulo que fornece a orientao do rob em relao ao
eixo Z. A orientao do rob medida em relao ao vetor formado entre suas duas
cores de identificao.
Em addRobots(), as principais mudanas foram feitas em relao s
funcionalidades do menu. Com as alteraes possvel receber o cdigo dos robs
ativos, exibir informaes tais como velocidade linear e angular atuais, executar a
tarefa e tambm interromp-la. Esta tornou-se a principal funo de controle de
execuo da aplicao proposta neste trabalho.
#include "windows.h"
#include <conio.h>
#include "cvcam.h"
#include "highgui.h"
#include <math.h>
#include <stdio.h>
#include "SistemaVisao.h"
#define TAM 480
#define LIDER 13 // codigo para ser interpretado pelo seguidor
#define DIST_SEGURA 15 // dist min que o robo fica do alvo antes de parar
void gotoxy(int x,int y);
void clrscr(void);
SistemaVisao::SistemaVisao(void) // construtor
{
coordSys = NULL;
basicProc = NULL;
teamTr = NULL;
NP = 0;
NP = 0;
addRobotsMode = 0;
for (int i = 0; i < 10; i++)
statusRobo[i] = 'a'; // p = parado, a = atividade
}
SistemaVisao::~SistemaVisao(void) // destrutor
{
}
Camera* SistemaVisao::iniciaCamera(VideoProcessor *VP)
{
Camera* cam;
67
clrscr();
int ncams = cvcamGetCamerasCount(); // numero de cameras ativas
if(ncams == 1){
cam = new Camera(0);
cam->setProcessor(VP); // quando um objeto iniciado com new
// usa-se esse tipo de referencia
}
else
if(ncams > 1){
int n;
printf("Existem %d cameras. Escolha uma:\n(Observe que 0
representa a primeira)",ncams);
gotoxy(35,0);
scanf_s("%d",&n);
cam = new Camera(n);
cam->setProcessor(VP);
}
else{
printf("Nao existem cameras instaladas.");
return NULL;
}
char c = 0;
cvNamedWindow("Config");
do{
clrscr();
gotoxy(10,5);
printf("Escolha uma das opcoes abaixo:\n\n");
printf(" -1: Escolher resolucao\n -2: Exibir janela de
configuracao\n -3: Iniciar Captura\n -4: Continuar");
gotoxy(42,5);

switch(c)
{
case '1': cam->videoFormat();
break;
case '2': cam->configure();
break;
case '3': cam->start();
break;
}
c = cvWaitKey(0);
}while(c != '4');
return cam;
}
void SistemaVisao::calibCoordS()
{
FILE* arq;
for(int i=0; i<4; i++) //Inicializa vetor de referencias
fieldRef[i] = Vec2f(0,0);
cvSetMouseCallback("Config", (void (__cdecl *)(int events, int x,
68
int y, int flags, void* param))mouseCallback, this);

int comando = 0;
do{
printFieldMenu(); //Imprime menu de configuracao do campo
comando = cvWaitKey(0);

switch(comando)
{
case '1':
case '2':
case '3':
case '4': fieldRef[comando-'1'] = mouseClkPos;
break;
//Cria sistema de coordenadas!!
case '5': coordSys = new CoordSystem(fieldRef);
gotoxy(5,12);
printf("Centro do sistema de coordenadas: (%03.0f,
%03.0f)\n",coordSys->Centro.x,
coordSys->Centro.y);
comando = '6';
break;
}
}while(comando != '6');
}
void SistemaVisao::calcBackGnd()
{
int quant;
basicProc = new BasicProcessor();
clrscr();
gotoxy(1,1);
// printf("Digite o numero de frames que deseja usar para
calcular fundo: ");
// scanf_s("%d",&quant);
quant = 2;
basicProc->calcBackGnd(30);
cvNamedWindow("BackGround");
gotoxy(5,5);
printf("\nCalculando...\nPressione qualquer tecla apos termino");
cvWaitKey(5000);
cvDestroyWindow("BackGround");
cvNamedWindow("Hue");
}
void SistemaVisao::addRobots() // procedimento principal
{
float cx1 = 0;
float cx2 = 0;
float cy1 = 0;
float cy2 = 0;
float xPosRobo = 0; // guarda posicao do robo em pixels,
// temporario apenas
float yPosRobo = 0;
float ExT = 0;
float EyT = 0;
char sinal = '0';
69
short int temp = 0;
CvPoint centroTarget; // centro do alvo
CvPoint centroRobo; // centro entre as duas cores do robo
int comando = 0;
addRobotsMode = 1;
com = new ComSerial();
teamTr = new TeamTracker(basicProc->getHue());
teamTr->setCoordSystem(coordSys);
cvSetMouseCallback("Config", (void (__cdecl *)(int events, int x,
int y, int flags, void* param))mouseCallback, this);
com->open(); // abre porta serial para comunicacao
// centro do campo
float Xo = 0;
float Yo = 0;

do{
clrscr();
gotoxy(0,1);
printf(" -1: Selecione a cor da frente do robo\n -2: Selecione
a outra cor\n -3: Criar jogador\n -4: Selecione a
cor do alvo\n -5: Criar alvo\n -6: Rastrear robos
ativos\n -7: Exibir informacoes dos robos\n -8:
Executar a tarefa programada\n -9: Interrompe a
tarefa (necessario para utilizar os itens do menu)\n
-s: Sair...\n");
gotoxy(5,12);
printf("Regiao Selecionada: (%d, %d, %d, %d)",window.x,
window.y, window.width, window.height);
switch(comando)
{
case '1': primaryArea = window;
break;
case '2': secondaryArea = window;
break;
case '3':
players[NP] = new DoubleTracker(basicProc->getHue(),
primaryArea, secondaryArea);
teamTr->addDoubleTracker(players[NP]);
centroRobo = players[NP]->getCenter(); // em pixels
// centro do robo - centro do sistema de coordenadas
xDest = centroRobo.x - coordSys->Centro.x;
yDest = -(centroRobo.y - coordSys->Centro.y);
// resultado em Xmundo e Zmundo, em cm
calcTransf(xDest,yDest,ALTURA_ROBO);
gotoxy(5,14);
printf("Posicao central do robo (X,Z), em cm:
(%03.0f,%03.0f)",Xmundo,Zmundo);
NP++;
break;
70
case '4': primaryArea = window;
break;
case '5': // alvo para todos os robos
gotoxy(5,14);
printf("IMPORTANTE! Apenas o ltimo alvo marcado
sera considerado!");
target = new SimpleTracker(basicProc->getHue(),
primaryArea);
teamTr->addSimpleTracker(target);
// armazena o centro da area do alvo, ponto na
// imagem 2D
centroTarget = target->getCenter();
// centro do robo - centro do sistema de coordenadas
xDest = centroTarget.x - coordSys->Centro.x;
yDest = -(centroTarget.y - coordSys->Centro.y);
// converte xDest e yDest para cm e guarda em
// Zmundo e Xmundo
// Calculo de Xm,Ym e Zm em centimetros
// resultado em Xmundo e Zmundo, em cm
calcTransf(xDest,yDest,ALTURA_MESA);
gotoxy(5,14);
printf("Ponto central do alvo (X,Z), em cm:
(%03.0f,%03.0f)",Xmundo,Zmundo);
// Zd e Xd, coordenadas do alvo em cm, no mundo
Xd = Xmundo; // Xd no mundo em cm
Zd = Zmundo; // Zd no mundo em cm
break;
case '6': // Rastreamento de robos ativos
printf("\n\nRastreando robos...");
// inicia o vetor buffer_recebido[];
for (int i = 0; i < NP; i++)
com->buffer_recebido[i] = '!'; // vazio!
for (int i = 0; i < NP; i++)
{
com->setBufferInfoSolicita(unsigned char(i));
com->write();
cvWaitKey(300); // espera 300 ms antes de
// ler, evita problemas de
// leitura incorreta
com->read();
com->buffer_recebido[i]=com->BufferRecebe[i];
}
printf("\nModulos encontrados (33 indica
inexistente):\n");
for (int i = 0;i < NP; i++)
printf("%d, ",com->buffer_recebido[i]);
cvWaitKey(2000);
break;
case '7': // exibe informaes dos robos
printf("\n\nUltimas informacoes dos robos...\n");
if (NP > 0)
{
71
for (int i = 0; i < NP; i++)
{
printf("\nInformacoes do Robo: %d\n
Velocidade Linear: %d\n Velocidade
Angular: %d\n",infoRobos[i]
[0],infoRobos[i][1],infoRobos[i][2]);
}
}
else
printf("\n\nNenhum robo foi detectado! Eles
foram adicionados no sistema de
visao?\n");
printf("\nAperte qualquer tecla para voltar ao
menu...");
cvWaitKey(0);
break;
case '8': // executar a tarefa
printf("\n\nModo de execucao...");
do
{
// varredura dos robores
for (int i = 0; i < NP; i++)
{
// operacao normal usando V_MAX = 50 e W_MAX =
// 5, encontradas nos experimentos
calcMove(50,5,i);
}
comando = '1'; // evita lixo em comando!
// INTERVALO DE CONTROLE
} while (comando != '9'); // sai do programa
// para todos os robos
for (int i = 0; i < NP; i++)
{
com->setBuffer(0,0,unsigned char(i));
com->write();
}
printf("\n\nSaindo do modo de execucao...\n");
cvWaitKey(1500);
break;
}
}while(comando != 's'); // sai do programa e para os robos
// parar todos os robos antes de sair do programa
for (int i = 0; i < NP; i++)
{
com->setBuffer(0,0,unsigned char(i)); // carrega buffer
com->write(); // escreve na porta serial
}
printf("\n\nSaindo do programa e parando os robos...\n");
cvWaitKey(1500);
com->close(); // fecha porta serial
}
72
void SistemaVisao::calcPositions()
{
}
void SistemaVisao::calibra()
{
calibCoordS();
calcBackGnd();
addRobots();
}
void
SistemaVisao::mouseCallback(int events,int x,int y,int flags,void* param)
{
SistemaVisao* self = ((SistemaVisao*)param);
y = TAM-y;
if (events == CV_EVENT_LBUTTONUP)
self->mouseClkPos = cvPoint(x,y);
if (self->addRobotsMode)
if (events == CV_EVENT_LBUTTONDOWN){
self->window.x = x;
self->window.y = y;
}
else if (events == CV_EVENT_LBUTTONUP){
self->window.width = x - self->window.x;
self->window.height = y - self->window.y;
}
}
DadosVisao* SistemaVisao::processaFrame(svImagem* F)
{
DadosVisao* dados = NULL;
cvShowImage("Config",F);
if (basicProc != NULL){
basicProc->processNewFrame(F);
if (teamTr != NULL)
dados = teamTr->findPositions(F);
if (!basicProc->isProcessing())
cvShowImage("BackGround",basicProc->getBackGnd());
else{
cvShowImage("Hue",basicProc->getHue());
}
}

return dados;
}
void SistemaVisao::printFieldMenu()
{
Vec2f ponto;

clrscr();
gotoxy(10,2);
printf("\nDigite um dos numeros abaixo para modificar um dos pontos
de referencia: ");
gotoxy(1,5);
73
printf("-1: Canto inferior esquerdo\n -2: Canto inferior direito\n
-3: Canto superior esquerdo\n -4: Canto superior direito\n -5:
Cria sistema de coordenadas e continua...");
for (int i=0;i<4;i++){
gotoxy(29,5+i);
printf("(%03.0f,%03.0f)", fieldRef[i].x, fieldRef[i].y);
}
if (coordSys != NULL)
{
gotoxy(0,15);
ponto = coordSys->transform(mouseClkPos);
printf("Original: (%03.0f, %03.0f), Campo: (%03.3f,
%03.3f)",mouseClkPos.x,mouseClkPos.x,ponto.x,ponto.y);
}
gotoxy(40,3);
}
void clrscr(void) //clear screen
{
CONSOLE_SCREEN_BUFFER_INFO csbiInfo;

HANDLE hConsoleOut;
COORD Home = {0,0};
DWORD dummy;
hConsoleOut = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleScreenBufferInfo(hConsoleOut,&csbiInfo);
FillConsoleOutputCharacter(hConsoleOut,' ',csbiInfo.dwSize.X *
csbiInfo.dwSize.Y,Home,&dummy);
csbiInfo.dwCursorPosition.X = 0;
csbiInfo.dwCursorPosition.Y = 0;
SetConsoleCursorPosition(hConsoleOut,csbiInfo.dwCursorPosition);
}
void gotoxy(int x,int y)
{
CONSOLE_SCREEN_BUFFER_INFO csbiInfo;

HANDLE hConsoleOut;
hConsoleOut = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleScreenBufferInfo(hConsoleOut,&csbiInfo);
csbiInfo.dwCursorPosition.X = x;
csbiInfo.dwCursorPosition.Y = y;
SetConsoleCursorPosition(hConsoleOut,csbiInfo.dwCursorPosition);
}
void SistemaVisao::calcTransf(float coordX, float coordY, int altura)
{
// Calculo de Xm,Ym e Zm em centimetros
Zmundo = altura * (FOCO * cos(FI) + coordY * sin(FI)) /
(FOCO * sin(FI) - coordY * cos(FI));
//Ymundo = -ALTURA;
Xmundo = (coordX / FOCO) * (altura * sin(FI) + Zmundo * cos(FI));
}
74
// faz os calculos e envia velocidades
void SistemaVisao::calcMove(int V_MAX, float W_MAX, int i)
{
float Ex,Ez;
CvPoint tempRoboTeam;
CvPoint tempRoboOrient;
int distEmp = 0;
float distEmpTemp = 0;

CvPoint Temp = players[i]->getCenter(); // centro entre as duas
// cores do robo, em pixels
xDest = Temp.x - coordSys->Centro.x; // centro do robo - centro
// do sistema de coordenadas
yDest = -(Temp.y - coordSys->Centro.y);
calcTransf(xDest,yDest,ALTURA_ROBO); // resultado em Xmundo e
// Zmundo, em cm
// Calculo do modulo do erro Ei nas 3 direcoes
// d = destino (alvo)
Ex = Xd - Xmundo;
Ez = abs(Zd) - abs(Zmundo);
// calculo de psi, angulo do centro do robo ao alvo
// em relacao ao eixo Z
// psi = atan(Ex/Ez); // original
psi = calcAngulo(Ex,Ez); // (cateto oposto/cateto adjacente)
// Calculo do modulo do erro E, distancia do robo ate o alvo
ModE = sqrt(pow(Ex,2) + pow(Ez,2)); // pow(5,2) = 5^2
// calculo de alfa, orientacao do robo em relacao ao eixo Z
tempRoboTeam = players[i]->primaryTr.getCenter();
xDest = tempRoboTeam.x - coordSys->Centro.x;
yDest = -(tempRoboTeam.y - coordSys->Centro.y);
calcTransf(tempRoboTeam.x,tempRoboTeam.y,ALTURA_ROBO);
tempRoboTeam.x = Xmundo;
tempRoboTeam.y = Zmundo;
tempRoboOrient = players[i]->secondaryTr.getCenter();
xDest = tempRoboOrient.x - coordSys->Centro.x;
yDest = -(tempRoboOrient.y - coordSys->Centro.y);
calcTransf(tempRoboOrient.x,tempRoboOrient.y,ALTURA_ROBO);
tempRoboOrient.x = Xmundo;
tempRoboOrient.y = Zmundo;
Ex = tempRoboOrient.x - tempRoboTeam.x; // - tempRoboOrient.x;
Ez = tempRoboOrient.y - tempRoboTeam.y; // - abs(tempRoboOrient.y);
//alfa = atan(Ex/Ez); // alfa original
alfa = calcAngulo(Ex,Ez);
// calculo de teta, angulo de giro para que o robo se oriente de
// acordo com o alvo
teta = psi - alfa;
if (statusRobo[i] == 'a')
{
if (ModE <= DIST_SEGURA)
75
{
clrscr();
printf("\nO centro do robo '%d' esta a menos de %d cm do
alvo e por isso foi parado!",i,DIST_SEGURA);
printf("\nAperte qualquer tecla para continuar...\n");
// para robo i
v = 0;
w = 0;
com->setBuffer(v,w,unsigned char(i));
statusRobo[i] = 'p'; // muda o status do robo de ativo
// para parado
cvWaitKey(0);
clrscr();
gotoxy(0,1);
printf(" -1: Selecione a cor da frente do robo\n -2:
Selecione a outra cor\n -3: Criar jogador\n -4:
Selecione a cor do alvo\n -5: Criar alvo\n -6:
Rastrear robos ativos\n -7: Exibir informacoes dos
robos\n -8: Executar a tarefa programada\n -9:
Interrompe a tarefa (necessario para utilizar os
itens do menu)\n -s: Sair...\n");
gotoxy(5,12);
printf("Regiao Selecionada: (%d, %d, %d, %d)",window.x,
window.y, window.width, window.height);
printf("\n\nModo de execucao...");
}
else
{
// calculo das velocidades linear e angular
// v = ModE * cos(teta);
// w = K * teta;
// calculo das velocidades linear e angular ja com o
// controlador aplicado
v = V_MAX * tanh(ModE) * cos(teta) * cos(teta);
w = W_MAX * tanh(teta);
com->setBuffer(v,w,unsigned char(i));
}
// guarda informacoes dos robos
infoRobos[i][0] = v;
infoRobos[i][1] = w;
infoRobos[i][2] = i;
}
}
float SistemaVisao::calcAngulo(float num, float den) //(num,den)
{
float angT1 = atan(num/den);
double pi = 3.1415926535; // 180 graus
float orientacao = 0;
// Identifica o quadrante em que o robo esta em relacao
// ao centro da regiao de testes. O eixo Z positivo e a
// referencia.
if ((num > 0) && (den > 0))
{
orientacao = angT1;
}
76
else if ((num > 0) && (den < 0))
{
orientacao = pi + angT1;
}
else if ((num < 0) && (den < 0))
{
orientacao = pi + angT1;
}
else
{
orientacao = 2*pi + angT1;
}
return orientacao;
}
77
REFERNCIAS BIBLIOGRFICAS
1. C. Soria, R. Carelli, R. Kelly, J. M. I. Zannatha. Control de Robots Cooperativos por
Medio de Vision Artificial. XVI Congreso de la Asociacin Chilena de Control Auto-
mtico, 2004.
2. R. Kelly, R. Carelli, J. M. Zannatha, C. Monroy. Control de una pandilla de robots
mviles para el seguimiento de una contelacin de puntos objetivo. VI Congreso
Mexicano de Robtica, 2004.
3. R. C. Arkin. Behavior-Based Robotics. The MIT Press, 1998.
4. R. R. Murphy. Introduction to AI Robotics. The MIT Press, 2000.
5. J. O. Bragana. Estratgias para Deslocamento de Cargas Atravs de Cooperao de
Robs Mveis a Rodas. Dissertao de Mestrado, UFES, Vitria, ES, 2004.
6. R. F. Vassallo. Cooperao de Robs baseada em Viso Omnidirecional. Projeto
PIBIC 2006-2007, UFES, Vitria, ES, 2006.
7. Inovao Tecnolgica. Robs cooperativos utilizam sensores e equipamentos uns dos
outros. Visitado em 09/12/2007.
http://www.inovacaotecnologica.com.br/noticias/noticia.php?artigo=010180060821
8. R. F. Vassallo. Uma Estratgia de Navegao para Robs Mveis em Ambientes
Interiores. Dissertao de Mestrado, UFES, PPGEE, Vitria, ES, 1998.
9. E. Zambon. Uma Plataforma para Desenvolvimento de Robs de Baixo Custo com
Alta Capacidade Computacional IROBOT. Projeto de Graduao, UFES, Vitria,
ES, 2004.
10. F. Pereira. Microcontroladores MSP430 Teoria e Prtica. 1
a
Edio, Editora rica,
2005.
11. Texas Instruments. MSP430F149 datasheet. Julho de 2000, Revisado em Junho de
2004.
12. MaxStream. Product Manual v1.xAx - 802.15.4 Protocol. Outubro de 2006.
13. A. T. Oliveira, H. T. Costa, e L. C. Maia. ZigBee Tecnologia e Aplicaes. Relatrio
apresentado disciplina de Sistemas de Telecomunicaes, UFES, Vitria, ES, 2006.
14. C. C. Gava. Controle de Formao de Robs Mveis Baseado em Viso
Omnidirecional. Tese de mestrado, UFES, Vitria, ES, 2007.
15. MFSM. CAMSHIFT Experiments. Visitado em 23/12/2007.
http://mfsm.sourceforge.net/MFSM_0.7/tutorials/Camshift.html
78

Higordtallescosta

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Higordtallescosta

Uploaded by

Copyright:

Available Formats

UNIVERSIDADE FEDERAL DO ESPRITO SANTO

You might also like