controle de um robô movel utilizando a tecnologia zigbee e a visão ...

UNIVERSIDADE FEDERAL DO ESPÍRITO SANTO
CENTRO TECNOLÓGICO
DEPARTAMENTO DE ENGENHARIA ELÉTRICA
PROJETO DE GRADUAÇÃO
CONTROLE DE UM ROBÔ MÓVEL
UTILIZANDO A TECNOLOGIA ZIGBEE
E A VISÃO COMPUTACIONAL
HIGOR D' TALLES COSTA
VITÓRIA – ES
DEZEMBRO/2007

HIGOR D' TALLES COSTA
CONTROLE DE UM ROBÔ MÓVEL
UTILIZANDO A TECNOLOGIA ZIGBEE
E A VISÃO COMPUTACIONAL
Parte escrita do Projeto de Graduação do
aluno Higor D' Talles Costa, apresentado
ao Departamento de Engenharia Elétrica
do Centro Tecnológico da Universidade
Federal do Espírito Santo, para obtenção
do grau de Engenheiro Eletricista.
VITÓRIA – ES
DEZEMBRO/2007

HIGOR D' TALLES COSTA
CONTROLE DE UM ROBÔ MÓVEL
UTILIZANDO A TECNOLOGIA ZIGBEE
E A VISÃO COMPUTACIONAL
COMISSÃO 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
Vitória - ES, 21, Dezembro de 2007.

DEDICATÓRIA
Aos meus pais, familiares e amigos, por toda a ajuda, incentivo e fé.
i

AGRADECIMENTOS
Agradeço primeiramente a Deus por ter me dado a força, ânimo e
discernimento para concluir este trabalho com êxito.
Aos meus pais, David e Carolina, pelo incessante apoio e força. Grandes
incentivadores. Agradeço pela fé e confiança depositadas em mim durante todo o
curso de Engenharia Elétrica, e também durante o desenvolvimento deste trabalho.
Aos meus irmãos, Érico e Caroline, pelo apoio, fé e amizade.
À Prof a . Raquel Frizera Vassallo, orientadora deste trabalho, pela atenção e
disponibilidade. A proposta do trabalho foi bastante desafiadora e alinhada com meus
interesses pessoais e profissionais. Não poderia deixar de agradecê-la pelo incrível
suporte e conhecimento técnico em Visão Computacional que foram amplamente
aplicados neste trabalho. Por ela tenho enorme admiração, respeito e confiança.
Ao Julio e ao Clebson, estudantes de Engenharia de Computação, que
gentilmente cederam os códigos que serviram de base para a parte de Visão
Computacional.
Ao Christiano, aluno de Doutorado, por ter cedido o código do MSP430 que
serviu de base para a aplicação desenvolvida para o robô.
À Prof a . Carmen, responsável pelo Laboratório de Robótica Educacional, por
ter gentilmente aberto as portas desse laboratório para que eu trabalhasse na fase de
testes. Sem isso, certamente eu não teria atingido os resultados tão rapidamente.
Ao Thierry, monitor do Laboratório de Robótica Educacional, pelo apoio,
momentos de bate-papo e também pela curiosidade, pois isso me fez reavaliar alguns
conceitos aplicados a este trabalho. Essas reflexões foram muito importante para a
tomada de algumas decisões de projeto.
Finalmente, a todos aqueles cujos nomes não mencionei, embora tenham tido
sua importância em muitos momentos da minha vida acadêmica. Agradeço também
aos que contribuíram direta ou indiretamente para que este trabalho se tornasse
possível.
ii

LISTA DE FIGURAS
1 - PLACA PRINCIPAL DO ROBÔ..................................................................................................................15
2 - ESQUEMA DE LIGAÇÃO DA PLACA PRINCIPAL................................................................................16
3 - ESQUEMA DE LIGAÇÃO DO PC À PLACA PRINCIPAL......................................................................16
4 - CONJUNTO DE DESENVOLVIMENTO DA MAXSTREAM..................................................................19
5 - ANÁLISE DE CONEXÃO COM O X-CTU................................................................................................20
6 - TELA DE CONFIGURAÇÃO DA COMUNICAÇÃO SERIAL.................................................................21
7 - TELA DE TESTES DO X-CTU....................................................................................................................21
8 - TELA DE CONFIGURAÇÃO DO XBEE....................................................................................................22
9 - SINTAXE PARA O MODO DE COMANDO AT.......................................................................................23
10 - EXEMPLOS DE PROGRAMAÇÃO EM MODO DE COMANDO AT.....................................................23
11 - PINAGEM DO MSP430F149.......................................................................................................................26
12 - COMUNICAÇÃO SERIAL ENTRE XBEE E MICROCONTROLADOR.................................................27
13 - ROBÔ E ALVO COM SUAS RESPECTIVAS CORES..............................................................................31
14 - RECONHECIMENTO DE CORES..............................................................................................................31
15 - REFERÊNCIAS DO SISTEMA ÓPTICO....................................................................................................32
16 - FORMAÇÃO DA IMAGEM EM UMA CÂMERA PERSPECTIVA.........................................................35
17 - MODELO DA CÂMERA PERSPECTIVA COM PROJEÇÃO DE PONTO..............................................36
18 - RELAÇÃO 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 RUÍDOS GERADOS COM O SISTEMA EM FUNCIONAMENTO.........49
iii

LISTA DE TABELAS
1 - CARACTERÍSTICAS DO PADRÃO 802.15.4..............................................................................................17
2 - CARACTERÍSTICAS DO XBEE E DO XBEE PRO....................................................................................18
3 - COMPARAÇÃO DE TEMPOS DE RESPOSTA ENTRE ZIGBEE E BLUETOOTH.................................18
iv

GLOSSÁRIO
BSL – BOOTSTRAP LOADER, UTILIZADO PARA PROGRAMAÇÃO DO MSP430.
CAMSHIFT – CONTINUOUSLY ADAPTATIVE MEAN SHIFT. ROBUSTA TÉCNICA INTERATIVA E
NÃO-PARAMÉTRICA PARA ENCONTRAR UM MODO DE DISTRIBUIÇÃO DE
PROBABILIDADE.
DCO – OSCILADOR CONTROLADO DIGITALMENTE.
DI
– DATA IN, PINO DE ENTRADA DE DADOS DO XBEE.
DO – DATA OUT, PINO DE SAÍA DE DADOS DO XBEE.
FRAME – É CADA QUADRO CAPTURADO PELA CÂMERA.
HUE – CANAL DA MATIZ NO SISTEMA DE COR HSV.
HSV – SISTEMA DE COR.
MEAN SHIFT – ALGORÍTMO DE MULTIPROCESSAMENTO DE DADOS GERALMENTE UTILIZADO
EM APLICAÇÕES DE VISÃO 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 INSTRUÇÕES.
WEBCAM – TIPO DE CÂMERA EM GERAL UTILIZADA EM COMPUTADORES E NÃO COSTUMA
APRESENTAR ALTA QUALIDADE NA CAPTURA DE IMAGENS, ALÉM DE SER UM
DISPOSITIVO QUE REALIZA AJUSTES AUTOMÁTICOS DA IMAGEM SEM A
INTERVENÇÃO DO USUÁRIO.
v

SUMÁRIO
DEDICATÓRIA.........................................................................................................I
AGRADECIMENTOS..............................................................................................II
LISTA DE FIGURAS..............................................................................................III
LISTA DE TABELA...............................................................................................IV
GLOSSÁRIO.............................................................................................................V
SUMÁRIO................................................................................................................VI
RESUMO..............................................................................................................VIII
1 INTRODUÇÃO.......................................................................................................9
1.1 Motivação........................................................................................................9
1.2 Trabalhos Similares.......................................................................................10
1.3 Descrição e Objetivo do Projeto....................................................................11
2 HARDWARE DO SISTEMA...............................................................................14
2.1 Introdução......................................................................................................14
2.2 Placa Principal do Robô.................................................................................14
2.3 Tecnologia ZigBee.........................................................................................17
2.3.1 XBee e suas Características..................................................................17
2.3.2 Programa de Configuração e Testes.....................................................19
2.3.3 Métodos de Programação.....................................................................22
2.4 O Microcontrolador MSP430.........................................................................24
2.4.1 Principais Características do Microcontrolador....................................25
2.4.2 O Programa do MSP430.......................................................................26
2.5 Conexão do XBee com o MSP430.................................................................27
vi

3 PROCESSAMENTO DE IMAGENS .................................................................29
3.1 Introdução......................................................................................................29
3.2 Técnica Utilizada...........................................................................................29
3.3 Considerações Iniciais de Projeto..................................................................32
3.3.1 Modelagem Matemática do Sistema Óptico.........................................33
3.3.1 Sistema de Orientação..........................................................................39
3.4 Captura e Processamento da Imagem.............................................................40
4 SISTEMA COMPLETO E TAREFA PROPOSTA...........................................42
4.1 Introdução......................................................................................................42
4.2 Montagem do Sistema e Detalhes de Funcionamento....................................42
4.3 Tarefa Proposta..............................................................................................44
5 EXPERIMENTO...................................................................................................46
5.1 Introdução......................................................................................................46
5.2 Teste e Análise dos Resultados......................................................................46
6 CONCLUSÃO.......................................................................................................50
6.1 Trabalhos Futuros..........................................................................................51
APÊNDICE A...........................................................................................................52
APÊNDICE B...........................................................................................................57
REFERÊNCIAS BIBLIOGRÁFICAS...................................................................78
vii

RESUMO
Este trabalho aborda a criação de um sistema de controle de robôs móveis
utilizando-se para isso técnicas de visão computacional e recursos de comunicação
sem fio providos pelo dispositivo XBee que implementa a tecnologia ZigBee. O robô
foi também equipado com uma placa de controle com um microcontrolador MSP430,
da Texas Instruments. A tarefa principal deste trabalho visa a movimentação de um
robô em um ambiente utilizando-se realimentação por imagem e troca de informações
à distância. Para isso, foi utilizada uma câmera com inclinação e altura conhecidas. A
câmera 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 indicação colorida para permitir o seguimento de cor
durante a movimentação do robô. Com o auxílio de algumas relações matemáticas
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

9
1 INTRODUÇÃO
1.1 Motivação
Muitos trabalhos têm sido desenvolvidos para que as habilidades de robôs
sejam aperfeiçoadas e ampliadas. Existem robôs para executar tarefas perigosas, como
é o caso de trabalhos realizados nas proximidades de vulcões em atividade, e robôs
para executar tarefas do dia-a-dia, como é o caso de robôs projetados para cuidar de
crianças e até mesmo para brincar. Esses robôs especializados, e com sensoriamento
variado envolvendo técnicas avançadas tanto de eletrônica quanto de computação, são
capazes de agir sozinhos descobrindo ambientes, aprendendo e até mesmo tomando
decisões.
Mesmo com as diversas possibilidades que as tecnologias atuais permitem,
muitas vezes não é viável utilizar robôs tão avançados em tarefas nem sempre tão
complicadas. Devido a isso, o desenvolvimento de robôs mais simples, capazes de agir
em grupo, tem sido cada vez mais freqüente para aplicações que envolvem diversos
módulos trabalhando em conjunto para atingir um objetivo [1, 2]. Esta alternativa
oferece vantagens potenciais em termos de flexibilidade de funcionamento [3, 4].
Existem diversas aplicações em que essa metodologia faz-se necessária, 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 cooperação não só são desenvolvidos para que os
componentes do grupo hajam em conjunto, mas também visam o compartilhamento de
recursos tais como câmeras, dados de posicionamento, etc [7]. Esse tipo de cooperação
é baseada no comportamento humano, onde nem todos os membros de uma equipe têm
as mesmas habilidades, embora possam suprir suas necessidades buscando recursos
em outros componentes do grupo.
A visão computacinal pode ser aplicada a diversas situações. Hoje em dia tem
sido cada vez mais difundidas aplicações desenvolvidas para ambientes inteligentes.
Em geral, aplicações como essas consideram vários pontos fixos para a observação da

10
cena. No entanto, em alguns casos, as câmeras se movem a fim de acompanhar os
objetos a serem seguidos no ambiente.
No que diz respeito a trabalhos desenvolvidos por times de robôs, em alguns
casos, pode-se ter um observador da cena que controla os demais membros da equipe
na execução de tarefas. Esse papel pode ser feito por um robô líder, que também 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. Além disso, nessas aplicações é preciso
ter um sistema de comunicação, que neste caso, isso é feito utilizando-se a tecnologia
ZigBee.
1.2 Trabalhos Similares
Muitos trabalhos já foram desenvolvidos a respeito de cooperação de robôs. As
aplicações mais comuns envolvem robôs que executam tarefas como empurrar caixas,
carregar objetos, realizar formações específicas e agir em sincronia [1, 2, 5].
Em geral, um dos meios de comunicação mais utilizados é a porta serial, padrão
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 comunicação funciona bem em
sistemas em que o robô tem movimentos bastante limitados ou mesmo em sistemas
articulados com base estática.
Em adição ao sistema de comunicação, muitos projetos contam também com o
processamento de imagem a fim de localizar texturas e objetos no ambiente. Essas
informações são úteis para que o robô consiga se locomover no ambiente e também
para que a tarefa a ser executada seja bem sucedida, pois leva em consideração
marcações 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 câmera, a complexidade do problema
pode ser aumentada ou diminuída significativamente. Imagens omnidirecionais
envolvem complexidades maiores e podem gerar problemas ou imprecisões de acordo

11
com tamanho do objeto a ser detectado. Ainda assim, com esse sistema pode-se
movimentar o robô levando-o a qualquer ponto visível da imagem [14]. Este tipo de
imagem tem aplicações mais interessantes quando a câmera é embarcada em sistemas
móveis. Por outro lado, imagens projetivas envolvem complexidades menores e são
mais indicadas para sistemas em que a câmera permanece parada enquanto os robôs se
movimentam em seu campo de visão.
Para o caso de robôs 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 necessária a comunicação por um meio seguro, veloz e com alta
capacidade de adição de nós ao sistema. A utilização do XBee garante ao sistema toda
a flexibilidade e independência necessárias para que os robôs se locomovam
livremente ao executar as tarefas.
1.3 Descrição e Objetivo do Projeto
Sistemas como os anteriormente apresentados podem se tornar ainda mais
interessantes quando combinados com módulos de comunicação sem fio. Isso confere
maior autonomia aos robôs, já que não estariam sujeitos a limitações impostas por
cabos tais como altos custos de instalação, necessidade de espaço físico adequado, e
também perda de informações devido às características intrínsecas do cabo. No
entanto, perdas também podem ocorrer utilizando-se comunicação sem fio, mas devido
à facilidade de instalação estas podem ser minimizadas utilizando-se algoritmos
corretores de erros. Pode-se também utilizar sistemas de comunicação multi-rota. Este
tipo de sistema pode reduzir sensivelmente a ocorrência de falhas de comunicação.
Para visão computacional, utiliza-se imagens projetivas devido à simplicidade
de processamento quando comparado ao processamento de imagens omnidirecionais.
Os robôs são 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 módulos funcionais tais como Ponte H, interface
J-Tag, interface de programação serial para o programador BSL (BootStrap Loader),

12
interface de controle via comunicação serial, entre outros que serão detalhados em
outros itens.
Cada robô conta também com uma placa de desenvolvimento contendo um
módulo de comunicação sem fio da tecnologia ZigBee. O módulo utilizado foi o XBee
do fabricante MaxStream. Esse módulo possui diversas características adequadas a
operações seguras de redes e também uma capacidade bastante elevada de
endereçamento de nós de rede. Além disso, trata-se de um dispositivo com um
consumo de energia extremamente baixo e capaz de trabalhar com distâncias bastante
elevadas, cerca de 100 metros sem antenas especiais. Este sistema apresenta boas
características de transmissão operando na faixa de freqüência de 2.4 GHz, no Brasil.
Para auxiliar a movimentação dos robô no ambiente, o sistema é também
equipado com uma câmera para captura das imagens que serão processadas. Para isso,
é instalada uma câmera no ambiente de testes e com as imagens capturadas é possível
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 código fonte aberto. Ela é chamada OpenCV e possui
diversas funções que tornam mais fácil a detecção e o seguimento de cor, tal como é
feito neste trabalho. A versão utilizada é a 1.0.
O robô utilizado neste trabalho é construído em acrílico e utiliza a placa de
circuito desenvolvida em [9]. Suas dimensões são de aproximadamente 10x15 cm.
Possui 3 rodas, tração diferencial, e para controlá-lo são enviadas as velocidades
linear, v, e angular, ω, para a porta serial da placa embarcada que controla suas
funções. Internamente, no programa do MSP430, essas velocidades são utilizadas para
compor as velocidades das rodas esquerda e direita. O robô é alimentado por uma
bateria de chumbo a uma tensão de 14 volts. A tensão de alimentação se sua placa
principal é de 9 volts, conseguidos com um regulador de tensão.
Com tudo devidamente ajustado, é então possível a realização de testes. O
principal objetivo deste trabalho é fazer com que um robô marcado com duas cores de
identificação, uma na parte traseira e outra na dianteira, partindo de uma orientação
qualquer no plano de execução da tarefa, consiga chegar ao ponto marcado como

13
destino, e marcado com uma terceira cor. A tarefa é realizada tendo-se como base o
seguimento de cor desenvolvido com funções da biblioteca OpenCV. Toda a
comunicação é feita do ponto fixo para o robô, isto é, o robô não envia informações.

14
2 HARDWARE DO SISTEMA
2.1 Introdução
A placa de circuito principal, que controla as funções do robô foi concebida no
projeto [9]. Apesar de ser composta por diversos módulos funcionais, apenas alguns
são relevantes a este projeto. Dentre eles, os principais são:
➢
➢
interface de programação via porta serial;
interface de controle via porta serial;
➢ ponte H.
A placa descrita acima é conectada ao módulo de Rádio Freqüência (RF),
XBee, e este é conectado ao MSP430 via porta serial. O módulo RF apresenta muitas
facilidades em relação à comunicação, já que, uma vez ajustado, a comunicação é feita
de modo transparente e descomplicado. As características desse transceptor podem ser
vistas em [12], no entanto, algumas das suas principais características relevantes a este
projeto são:
➢
➢
➢
operação na freqüência não-licenciada de 2.4 GHz;
taxas de transmissão relativamente altas quando comparadas a tecnologias
como bluetooth e WiFi;
baixo consumo.
Os detalhes funcionais dos circuitos citados, bem como as ligações entre os
módulos e os ajustes necessários para que tudo funcione conforme esperado, são
descritos nos próximos 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 funções o microcontrolador
MSP430F149.

15
Dentre os circuitos funcionais dessa placa, pode-se destacar aqueles que são
essenciais para este projeto e que já foram citados acima. Alguns módulos não são
utilizados ou porque não são úteis a este projeto ou porque não foram devidamente
testados e por isso seu uso não foi considerado, como é o caso do circuito responsável
pela interface J-Tag do MSP430. A placa citada pode ser vista na Figura 1 com seus
principais circuitos em destaque.
Figura 1: Placa principal do robô.
Devido ao fato dessa placa ainda não contar com um manual de utilização, fazse
necessário o detalhamento do cabo de comunicação serial, e também de algumas
configurações relativas a pinagem das partes em destaque da figura acima. Na Figura
2, pode-se ver os detalhes necessários da pinagem para que as ligações sejam
realizadas de maneira correta. Na Figura 3, pode-se ver a configuração do cabo
utilizado para gravação do MSP430 e também para o controle da placa.

16
Figura 2: Esquema de ligação da placa principal.
Figura 3: Esquema de ligação do PC à placa principal.

17
2.3 Tecnologia ZigBee
Hoje em dia tem sido cada vez mais comum a busca por técnicas de transmissão
de dados sem fios. Diversos padrões já foram concebidos e atendem hoje a quase todas
as necessidades tanto de clientes residenciais quando industriais. No entanto, um
desses padrões, o ZigBee, merece especial destaque por suas características. Este
padrão foi criado pela ZigBee Alliance com o intuito de prover comunicação sem fio
de modo confiável, com baixo consumo e com taxas razoáveis de transmissão para
monitoramento e controle, além de ser uma tecnologia aberta.
Este padrão possui elevada capacidade de endereçamento de pontos de rede
trabalhando em faixas de freqüências abertas e consumindo pouquíssima potência,
tanto em modo de operação normal quanto em modo standby. O padrão ZigBee, IEEE
802.15.4, foi homologado em maio de 2003. Este padrão tem como foco aplicações de
rádio freqüência que requerem baixas taxas de transmissão de dados, baixo consumo
de potência 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 Características
Como já foi citado, o padrão ZigBee apresenta muitas características
interessantes as quais o tornam muito superior em relação ao padrão Bluetooth, IEEE
802.15.1. Para mais detalhes e comparações entre os dois padrões vide [13].
Nas Tabelas 1, 2 e 3, seguem algumas características importantes encontradas
no padrão ZigBee e, em particular, nos dispositivos XBee e XBee Pro [12].
Padrão Freqüências Nº de canais Técnica de Modulação 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: Características do ZigBee, padrão 802.15.4.
1
DSSS (Direct Sequence Spread Spectrum), Espalhamento Espectral por Seqüência Direta.

XBee
XBee Pro
Item Características Item Características
Ambiente interno / Urbano 30 m Ambiente interno / Urbano 100 m
Ambiente externo com visada Até 100 m
Ambiente externo com visada Até 1500 m
Potência de transmissão 1 mW (0 dBm) Potência de transmissão 100 mW (20 dBm) EIRP
Sensibilidade de transmissão -92 dBm Sensibilidade de transmissão - 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 potência < 10 μA Corrente em baixa potência < 10 μA
Antena acoplada de fio - Antena RPSMA 2.4 GHz, 2.1 dBi
Tabela 2: Características do XBee e do XBee Pro.
18
Item
Tempo de Resposta
ZigBee
Tempo de acesso a rede 30 ms 3 s
Tempo de transição dos dispositivos escravos dos
estado dormindo para o estado ativo
15 ms 3 s
Bluetooth
Tempo de acesso ao canal 15 ms 2 ms
Tabela 3: Comparação de tempos de resposta entre ZigBee e Bluetooth.
O ZigBee foi concebido para operar em faixas de freqüências livres. Na Europa,
a operação é feita em 868 MHz, nos Estados Unidos, em 915 MHz, e em muitas outras
regiões do planeta, incluindo o Brasil, a operação é feita em 2.4 GHz.
A Tabela 1 mostra algumas características dependentes da freqüência de
operação. Nessa tabela, pode-se ver a relação da freqüência com o números de canais
de comunicação, técnica de modulação suportada bem como as taxas de transmissão
que podem ser alcançadas.
Na Tabela 2 podem ser vistas as principais características dos modelos XBee e
do XBee Pro. Como pode ser notado, a relação entre distância, potência e taxa de
transmissão faz do padrão 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 eficiência energética do sistema é possível graças a
um amplo conjunto de comandos capaz de colocar e dispositivo em modo de
economia, fazer medição de bateria, nível de sinal, entre outros. Com isso, desde que o
projeto seja bem desenvolvido pode-se aproveitar ao máximo suas características.

19
A Tabela 3 mostra informações importantes à respeito de tempos de resposta.
Para fins de comparação, nessa mesma tabela encontram-se os tempos de resposta
típicos para o padrão Bluetooth. O ZigBee é superado apenas no tempo de acesso ao
canal, mas nos outros dois itens listados sua resposta é muito mais rápida.
A Figura 4 mostra o conjunto de desenvolvimento da MaxStream utilizado
neste projeto e também os dois chips citados acima.
Figura 4: Conjunto de desenvolvimento da MaxStream.
2.3.2 Programa de Configuração e Testes
No conjunto de desenvolvimento da MaxStream pode-se encontrar também um
aplicativo chamado X-CTU. Esse aplicativo é utilizado para configurar as
características de funcionamento do XBee e também para testar a transmissão e o
recebimento de dados. Algumas das principais características desse programa estão
listadas abaixo:
➢
➢
➢
➢
facilidade de uso em testes de loopback a distância;
mostra um Indicador de Potência do Sinal Recebido (RSSI);
atualização de firmware do XBee;
automaticamente detecta o tipo de módulo;

➢
➢
20
restaura parâmetros de fábrica;
integra-se ao LabView e outras ferramentas de teste.
Este aplicativo é muito importante e graças a ele é possível avaliar a intensidade
do sinal recebido e então criar gráficos e estudos assim como feito em [13]. A Figura 5
abaixo mostra uma maneira típica de se utilizar o X-CTU em um teste de loopback.
Figura 5: Análise de conexão com o X-CTU.
As Figuras 6 e 7 mostram a tela de configuração da comunicação serial e a tela
de testes. Na tela de configuração, Figura 6, é possível fazer ajustes de velocidade de
comunicação, bits de paridade, entre outros. As configurações utilizadas para este
trabalho podem ser vistas nessa figura. Na tela de testes, Figura 7, é mostrada a barra
indicativa da potência do sinal recebido pelo módulo XBee conectado ao computador.
Nesse caso, o transmissor que está conectado ao computador envia o sinal a um outro
módulo XBee equipado com um conector de loopback, e com isso, o sinal volta ao
transmissor e pode-se então saber quantos pacotes enviados foram recebidos de volta,
e pode-se também medir a intensidade do sinal entre os módulos de comunicação.

21
Figura 6: Tela de configuração da comunicação serial.
Figura 7: Tela de testes do X-CTU.

22
Na Figura 8, é mostrada a tela de configuração do circuito integrado do XBee.
Nesse janela é possível acessar todas as informações do módulo, mudar parâmetros e
até mesmo atualizar o firmware. Caso sejam feitas configurações inadequadas, é
possível também ajustar o dispositivo com os parâmetros originais de fábrica.
Figura 8: Tela de configuração do XBee.
2.3.3 Métodos de Programação
Para modificar parâmetros do módulo RF tais como taxa de transmissão, modo
de comunicação (broadcast ou ponto-a-ponto), atualização de firmware entre outros,
primeiro é necessário 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 são interpretados como comandos e não como dados.
Com isso, as informações recebidas servem para alterar diretamente os campos de
configuração do dispositivo. Há atualmente duas maneiras de se programar os módulos
da MaxStream, a primeira é chamada Modo de Comando AT e a segunda, Modo de
Comando API. A maneira mais simples de se alterar os parâmetros é 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 não é detalhado neste trabalho.
Para entrar em Modo de Comando AT, deve-se selecionar a aba “Terminal” do
aplicativo X-CTU. Feito isso, para começar o modo de comando basta enviar à porta

23
serial do XBee a seqüência de caracteres “+++”, sem as aspas, e em seguida pode-se
enviar qualquer comando válido.
No caso de envio de comandos para o XBee enquanto ele está em modo de
operação, pode-se fazer necessário o envio do comando CT (Command Mode
Timeout), que informa ao XBee quanto tempo o módulo deverá aguardar por um
comando até que saia automaticamente do modo de comando. Caso isso aconteça, o
módulo retorna automaticamente ao modo de operação. Após configurado o CT, os
comandos de configuração podem ser enviados pelo usuário. Apesar de o módulo
poder sair automaticamente do Modo de Programação é possível sair explicitamente
enviando o comando CN (Exit command mode).
A sintaxe dos comandos bem como um exemplo de programação no Modo de
Comando AT podem ser vistos nas Figuras 9 e 10, respectivamente.
Figura 9: Sintaxe para o Modo de Comando AT.
Figura 10: Exemplos de programação em Modo de Comando AT.
Os modos de comando citados possibilitam a mudança dinâmica dos parâmetros
do dispositivo XBee. Dentre os comandos que podem ser aplicados ao dispositivo,

24
pode-se citar alguns de extrema importância ao se desenvolver projetos mais
elaborados e que fazem valer a adoção desse dispositivo. Alguns comandos com uma
breve descrição são listados abaixo:
➢
➢
➢
➢
ND (Node discover): descobre e reporta todos os módulos de RF encontrados;
PL (Power level): seleciona/lê a potência utilizada para a transmissão;
SM (Sleep mode): configurações para modo de baixo consumo;
VR (Firmware version): lê a versão do firmware do módulo RF.
Embora hajam muitas possibilidades para a melhor utilização das
funcionalidades do XBee, este trabalho faz uso dos módulos com suas configurações
ajustadas de acordo com o padrão de fábrica. Com isso, não é feito uso direto dos
modos de comando apresentados, embora essa apresentação tenha sido feita para que o
horizonte de aplicações pudesse ser melhor vislumbrado. Informações mais detalhadas
a respeito do conjunto de comandos e de outras características próprias do dispositivo
da MaxStream podem ser encontradas em [12].
2.4 O Microcontrolador MSP430
Os microcontroladores da Texas Instruments (TI) são divididos em várias
famílias de acordo com parâmetros tais como tipo de memória de programa e
aplicação. Atualmente existem cinco famílias. São elas:
➢
➢
➢
➢
➢
MSP430x1xx;
MSP430x2xx;
MSP430C3xx;
MSP430x4xx;
MSP430x5xx.
Este trabalho utiliza o MSP430F149, que é um dispositivo de uso geral dotado
de uma grande variedade de periféricos. Trata-se de um dispositivo com CPU RISC de
16 bits, registradores de 16 bits e geradores de constantes. Estes últimos contribuem

25
para a geração de códigos com máxima eficiência. O DCO (Oscilador Controlado
Digitalmente) permite reativar o dispositivo em menos de 6 μs. Essa CPU opera em 8
MHz.
A família MSP430F14x ainda tem 2 temporizadores internos de 16 bits, um
rápido conversor Analógico/Digital (A/D) de 12 bits, duas interfaces seriais universais
Síncronas/Assíncronas (USART) e ainda 48 pinos de Entrada/Saída.
Aplicações típicas incluem sistemas de sensoriamento que capturam sinais
analógicos, converte-os para sinais digitais e então os processa e transmite a outro
sistema. Os contadores internos são ainda ideais para aplicações de controle industrial
tais como controle digital de motores e medidores portáteis.
2.4.1 Principais Características do Microcontrolador
O MSP430 possui diversas características interessantes e que o diferencia muito
de outros microcontroladores. Algumas dessas características estão listadas abaixo:
➢
➢
➢
➢
➢
➢
➢
baixas tensões de alimentação (1.8 V a 3.6 V);
baixíssima potência consumida;
➔
➔
modo ativo: 280 μA a 1 MHz, 2.2 V
modo standby: 1.6 μA
modo desligado (retenção de memória RAM): 0.1 μA
interface de comunicação serial (USART), que pode funcionar como UART ou
mesmo como interface SPI;
memória flash e RAM;
➔
➔
60 KB + 256 B de memória flash
2 KB de memória RAM
operação em 8 MHz;
alto desempenho dos códigos compilados em C/C++ devido às características
de sua arquitetura e também por utilizar memória plana.

26
A Figura 11 mostra a pinagem do modelo utilizado neste trabalho. Suas
dimensões máximas são 12.20 x 12.20 x 1.20 mm e o encapsulamento é do tipo S-
PQFP-G64.
Figura 11: Pinagem do MSP430F149.
2.4.2 O Programa do MSP430
O programa que controla as funções da placa principal do robô foi escrito em C
e a listagem completa pode ser vista no APÊNDICE A. Esse código é uma adaptação
do código desenvolvido no trabalho [14].
No código original, basicamente foi implementado um controle dos motores
utilizando Modulação por Largura de Pulso (PWM), um controlador integrador para
ser utilizado com os encoders e o tratamento de interrupções necessário para o
recebimento de dados pela porta serial.
Para atender às necessidades deste trabalho, foram feitas algumas mudanças.
Como os encoders ainda não estão sendo utilizados, o código relativo a esta função foi

27
desativado. O controle do robô passou a ser feito pelo programa de visão
computacional, logo, o controlador integrador foi também removido do código. O
programa do MSP sofreu também algumas alterações a fim de torná-lo mais simples e
menos exigente em termos de processamento. Adicionalmente, um código
identificador do robô foi inserido ao programa para assegurar que a tarefa seria
executada pelo robô correto, no caso de haverem mais robôs envolvidos em uma
aplicação.
2.5 Conexão do XBee com o MSP430
Para alcançar os objetivos deste projeto, foi necessário configurar tanto o
conjunto XBee quanto o MSP430 para que ambos pudessem trabalhar em perfeita
sintonia, aproveitando ao máximo as características particulares de cada um.
As principais configurações são feitas em relação à comunicação serial, visto
que, o XBee comporta-se como um meio físico durante a transmissão e recepção 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 complicações e diretamente.
Semelhantemente, para que o XBee receba dados, basta que estes sejam enviados para
seu endereço 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.
Figura 12: Comunicação serial entre XBee e Microcontrolador.

28
Como pode ser visto na Figura 12, o módulo de comunicação 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 comunicação
sem fios e sem complicações, e de maneira que seja transparente para o
microcontrolador no que diz respeito ao processo de transmissão e aos detalhes
particulares da comunicação via RF.
Por padrão, o XBee opera no Modo Transparente. Quando opera nesse modo, o
módulo opera como um simples repetidor de informações, isto é, todos os dados
recebidos pelo pino de entrada de dados, DI, são encaminhados para a transmissão em
RF. Quando os dados da transmissão RF são recebidos, eles são direcionados ao pino
de saída de dados, DO.
Se o módulo não pode transmitir os dados imediatamente, no caso de já estar
ocupado com o recebimento de dados, estes dados recebidos serialmente são
armazenados no buffer de DI. Os dados são empacotados e enviados caso o tempo de
empacotamento chegue ao fim ou caso sejam completados 100 bytes, tamanho
máximo do pacote.
Caso o buffer de DI fique completamente cheio, é necessário implementar
algum software ou hardware a fim de controlar o fluxo de dados para que não 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 não passam no
teste são silenciosamente descartados.

29
3 PROCESSAMENTO DE IMAGENS
3.1 Introdução
O processamento de imagens é muito utilizado em robótica. Essa técnica agrega
boas possibilidades às funcionalidades dos robôs.
Diversas tarefas podem ser realizadas utilizando-se imagens capturadas por uma
câmera. Em sistemas assim, a fim de complementar os robôs no quesito robustez,
outros tipos de sensoriamento podem ser utilizados para se aumentar a gama de
aplicações que esses robôs podem executar e também diminuir a possibilidade de
falhas. Sendo assim, evitam-se limitações decorrentes de situações adversas que
podem ocorrer no ambiente durante as atividades executadas pelos robôs.
Com o processamento de imagem é possível extrair informações do mundo real
em três dimensões (3D) a partir da projeção da imagem em duas dimensões (2D) [1,
6, 8, 9].
3.2 Técnica Utilizada
Dentre as várias técnicas que podem ser utilizadas, optou-se por aquela que
melhor se adequava ao propósito deste trabalho. Sendo assim, fixou-se uma câmera a
uma altura e inclinação conhecidas em relação ao plano em que o robô executaria a
tarefa, e a partir daí foi feita toda a modelagem matemática.
É importante ressaltar que foi feita a calibração do foco da câmera a fim de se
obter as medidas com maior precisão. O processo de calibração consistiu basicamente
na medida de um objeto, de largura conhecida, a várias distâncias da câmera, ambos
sobre uma superfície plana. Neste caso, obteve-se duas medidas em centímetros, a
distância da câmera ao objeto e a largura do objeto medido, e uma em pixeis, medida
manualmente com o auxílio do programa de visão computacional. De posse dessas três
medidas foi possível calcular o foco da câmera em pixeis pela expressão (1):
f = Dd
L
(1)

30
Onde:
f → foco da câmera, em pixeis;
D → distância entre a câmera e o objeto, em centímetros;
d → largura do objeto, em pixeis;
L → largura do objeto, em centímetros.
Após ajustado o foco da câmera, as imagens foram capturadas e então
processadas pelo programa escrito na linguagem C++ utilizando algumas funções da
biblioteca OpenCV. O código utilizado neste trabalho é uma adaptação de uma
aplicação desenvolvida por alunos do PET da Engenharia de Computação da UFES. O
projeto citado trata de uma aplicação da visão computacional a futebol de robôs cuja
orientadora é a mesma do presente trabalho. As principais funcionalidades desta
aplicação incluem:
➢
➢
➢
➢
➢
marcação da região onde os robô executará a tarefa;
seleção das cores do robô e do alvo;
controle de velocidade, orientação e posição no espaço;
seguimento de cor;
execução de tarefas.
A imagem da Figura 13 mostra o robô e o alvo com suas cores, e a Figura 14
mostra como esses elementos são reconhecidos pelo sistema de visão. Note que na
Figura 14 as regiões já estão selecionadas para o sistema de seguimento de cor.
O sistema de seguimento de cor foi desenvolvido utilizando-se algumas funções
da biblioteca OpenCV e é baseado no CAMSHIFT [15]. Com essa técnica é possível
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 projeção da imagem.
Com isso, se o histograma possui uma certa distribuição de probabilidade, então a
tabela de cor gerada também terá o mesmo modelo de distribuição. O CAMSHIFT
detecta o modelo de distribuição de probabilidade aplicando o Mean Shift enquanto
dinamicamente ajusta os parâmetros da distribuição da cor a ser seguida. Note que o
algoritmo do CAMSHIFT segue apenas a cor selecionada. Assim, pela análise de

31
probabilidade a seleção da cor a ser seguida será atualizada, e servirá como ponto de
partida para a localização da cor a ser seguida quando um novo frame for capturado. A
busca no novo frame é feita levando-se em consideração as proximidades da região do
frame antigo em que o objeto com a cor a ser seguida se encontrava. Melhores
resultados do seguimento de cor utilizando o CAMSHIFT são obtidos utilizando-se o
canal HUE, do sistema de cor HSV, e o histograma da cor.
Figura 13: Robô e alvo com suas respectivas cores.
Figura 14: Reconhecimento de cores.

32
A seleção da cor a ser seguida pelo sistema é feita de modo manual.
Primeiramente seleciona-se o canto esquerdo inferior e logo após o canto direito
superior. Feito isso, registra-se os pontos e então a região retangular é efetivamente
selecionada. No caso do robô, que neste trabalho é identificado por duas cores, após a
seleção das cores os centróides são conectados.
3.3 Considerações Iniciais de Projeto
Para a modelagem matemática do sistema óptico, algumas considerações foram
feitas. Primeiramente, a câmera foi colocada na parede a uma altura e ângulo
conhecidos. A partir dessa situação, foram definidas quais seriam as transformações
necessárias para se controlar os robôs no espaço 3D a partir da projeção 2D, capturada
pela câmera.
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
também sua posição de maneira bastante simplificada, já que com a mudança de
coordenadas é possível controlar o robô a partir de uma única referência.
Figura 15: Referências do sistema óptico.

33
3.3.1 Modelagem Matemática 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 também permite que as velocidades angular
e linear, e conseqüentemente a posição do robô no espaço, sejam controladas
diretamente através do referencial do robô.
Abaixo estão as definições matemáticas do problema, mas antes disso, algumas
definições fazem-se necessárias com relação ao sistema de coordenadas adotado.
➢
➢
➢
referencial do mundo → ambiente de teste;
referencial da câmera → ponto em que a câmera está afixada considerando sua
inclinação;
referencial do robô → ponto central da linha que conecta as duas cores do robô.
Posto isso, pode-se desenvolver a parte matemática do sistema. Para converter
um ponto representado no referencial do mundo para sua representação, ou seja,
coordenadas no referencial da câmera, tem-se:
P C
= R X
− P M
P M
= R X
P C
(2)
(3)
R X
− =
[1 0 0 0
1]
0 cos sen 0
0 −sen cos 0
0 0 0
(4)
Onde: P C → ponto no referencial da câmera;
P M
→ ponto no referencial do mundo;
R X → matrix de rotação em torno do eixo X;
ϕ → ângulo de inclinação da câmera em relação ao eixo Z.

[
X
C
Y C
Z C
1
]C
Substituindo as matrizes de R X , P C e P M encontramos:
Com isso, ao fazermos a multiplicação de matrizes acima encontramos os
pontos do mundo no referencial da câmera. :
assim:
=
[1 0 0 0
1]
0 cos sen 0
0 −sen cos 0
0 0 0
X C
= X M
Y C
= Y M
cos Z M
sen
Z C
= −Y M
sen Z M
cos
[
X
M
Y M
Z M
1
]M
A imagem obtida pela câmera é uma projeção perspectiva do ambiente. Sendo
34
(5)
(6)
(7)
(8)
x = f
X c
Z C
(9)
y = f
Y c
Z C
(10)
onde: f → distância focal em pixeis.
O modelo da câmera utilizada é o pinhole. Esse modelo se baseia na passagem
dos raios luminosos por um pequeno orifício na entrada da câmera e na sua projeção
em uma superfície plana, como mostrado na Figura 16. As câmeras baseadas nesse
princípio são chamadas câmeras perspectivas [8]. O plano R é o plano da imagem, F é
paralelo ao plano R e é chamado de plano focal.

35
Figura 16: Formação da imagem em uma câmera perspectiva.
temos:
x = f
Para relacionar o ponto na imagem com as coordenadas do ponto 3D no mundo
X M
−Y M
sen Z M
cos
(11)
y = f
Y M
cos Z M
sen
−Y M
sen Z M
cos
(12)
Sabendo-se que os pontos tridimensionais pertencem ao plano Y M = -H, no
referencial do mundo, temos:
x = f
X M
H sen Z M
cos
(13)
y = f Z M
sen − H cos
H sen Z M
cos
(14)
Isolando as variáveis X M e Z M , temos:

36
X M
= x f H sen Z M cos
(15)
Z M
= H
f cos y sen
f sen − y cos
(16)
A Figura 17 ilustra o modelo da câmera perspectiva com a projeção de um
ponto do mundo no plano da imagem. Normalmente o referencial de uma imagem é
tomado como sendo o canto superior esquerdo, por isso é necessária uma correção 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 relações utilizadas nos
experimentos para encontrar x e y são descritas pelas expressões (17) e (18).
(17)
x = x img
− x o
y = − y img
− y o
(18)
Figura 17: Modelo da câmera perspectiva com projeção de ponto.

37
Sendo assim, a partir de x e y na imagem podemos obter X M , Z M e Y M , com
Y M = -H, e então podemos calcular o erro de posição para o robô. Esse erro é na
verdade a distância entre a posição atual do robô e a posição para onde ele deve ir a
fim de executar a tarefa a ser realizada.
(19)
= Pos desejada
− Pos atual
⇒
Em cada eixo teremos um ∆ = ε, como abaixo:
X
= X d
− X
Y
= 0
Z
= Z d
− Z
(20)
(21)
(22)
O ângulo formado entre o eixo Z e a direção em que o robô deve se locomover
pode ser calculado com a seguinte expressão:
= arctg X
Z
(23)
A Figura 18 ilustra a relação do erro |ε| e do ângulo θ calculado de acordo com
a tarefa a ser executada.
Figura 18: Relação do erro com a tarefa a ser executada.
Note que o ângulo α é medido em relação ao eixo Z e indica a orientação do
robô. O ângulo ψ é também medido em relação ao eixo Z e é utilizado para medir a

distância angular entre o centróide do robô e o ponto em que se deseja chegar.
Finalmente, o ângulo θ é a diferença 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 posição do robô, Δx e Δz, pode-se calcular o
módulo de ε, a velocidades linear e a angular.
∣∣= X 2 Z
2
v Z
=∣∣ cos
= k
38
(24)
(25)
(26)
Onde: v Z = v → velocidade linear;
k → constante de proporcionalidade;
θ → erro angular entre o robô e o ponto alvo.
Finalmente, as expressões necessárias para o controle do robô estão
relacionadas nas expressões (27) e (28), sendo v a velocidade linear e ω a velocidade
angular. Foi utilizado um controlador hiperbólico devido à sua característica de
transição suave entre valores positivos e negativos de ω. Essa característica é muito
importante para que o robô tenha movimentos mais suaves e assim evita-se erros de
posição e também problemas de tempo de resposta dos motores no momento da
inversão do sentido de giro. Repare que V max e ω max são escolhidos levando-se em
consideração resultados práticos. 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 potência para a qual o
motor deve ser ajustado.
v = v max
tanh∣∣ cos 2
= max
tanh
(27)
(28)
A Figura 19 mostra um esboço da resposta da velocidade angular de acordo
com o ângulo θ instantâneo.

39
Figura 19: Resposta ideal do controlador.
Como pode ser visto, a resposta desse controlador garante um movimento
bastante suave para o motor evitando-se mudanças bruscas de velocidade e também
mudanças bruscas de corrente nos motores.
3.3.1 Sistema de Orientação
Com o perfeito funcionamento do sistema óptico é possível utilizar as
informações das imagens previamente capturadas e processadas para inferir a
orientação dos robôs no plano de atividade.
Como o robô utilizado não é equipado com sensores capazes de informar a atual
orientação, optou-se por utilizar duas cores para identificá-lo. Com isso, identificar a
posição do robô bem como sua orientação no sistema torna-se bastante simples quando
comparado ao método que utiliza apenas uma cor por robô. Sendo assim, uma cor é
marcada como sendo a parte de trás do robô, enquanto a outra é marcada como sendo a
parte da frente. Em seguida, os centróides são localizados e conectados. A partir destes
pontos, pode-se calcular a orientação do robô em relação ao eixo Z e também em
relação ao destino, representado por uma terceira cor.

A expressão que avalia tanto a orientação do robô quanto o ângulo entre o eixo
Z e o ponto alvo é descrita pela expressão (29). Note que Ang pode ser tanto α quanto
ψ.
Ang = arctg ΔƤ
Δɠ
(29)
Para calcular esses ângulos, foi necessário fazer algumas considerações para
que o ângulo encontrado estivesse sempre em relação a uma única referência. 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 não fosse
tomado, isso geraria um erro no momento em que o robô tivesse que se orientar no
sentido do alvo partindo de uma orientação aleatória.
Sendo assim, para o cálculo do ângulo, utilizou-se uma série de relações para
identificar em que quadrante encontrava-se o vetor velocidade do robô. As relações
levam em consideração 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π
40
Note que Ang é o valor calculado pela expressão (29) e Angulo é o valor
corrigido do ângulo para uma referência comum e única do sistema, considerada como
sendo o eixo Z positivo.
3.4 Captura e Processamento da Imagem
Além da captura, no sistema de visão foram implementadas funções a fim de
encontrar o centro dos objetos marcados na imagem. Isso é importante porque permite
que a manipulação do robô no ambiente seja simplificada, já que sua movimentação é
baseada na posição do seu centróide.

41
As funções de processamento de imagem fazem parte do sistema de visão
chamado Sistema Robótico, feito em C++. A manipulação das imagens é bastante
simples quando feita com o auxílio da biblioteca OpenCV da Intel. Embora todas as
funções do programa possam ser vistas na listagem do APÊNDICE B, algumas das
principais funções da biblioteca OpenCV relativas a este trabalho estão descritas
abaixo. São elas:
➢ cvcamGetCamerasCount();
➢
➢
➢
➢
➢
➢
➢
Retorna um inteiro com o número de câmeras ativas encontradas.
cvcamSetProperty(camIndex, CVCAM_PROP_ENABLE, CVCAMTRUE);
Habilita a câmera especificada em camIndex, sendo 0 o número da primeira.
cvcamSetProperty(camIndex, CVCAM_PROP_RENDER, CVCAMTRUE);
Habilita a digitalização dos frames para a câmera selecionada.
cvcamSetProperty(camIndex, CVCAM_PROP_SETFORMAT, &vidFmt);
Define resolução e quantidades de frames que serão capturados por segundo.
Para isso, vidFmt recebe uma matriz do tipo {640, 480, 30.0}.
cvcamGetProperty(camIndex, CVCAM_CAMERAPROPS, NULL);
Chama a janela de configuração dos parâmetros da câmera.
cvcamInit();
Prepara a câmera com os parâmetros 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 funções dessa biblioteca fazem boa parte do
trabalho e por isso poupam tempo de desenvolvimento de aplicações. Logo, essa
biblioteca acaba viabilizando aplicações em várias áreas que envolvem processamento
de imagens.

42
4 SISTEMA COMPLETO E TAREFA PROPOSTA
4.1 Introdução
O sistema completo é formado por um robô equipado com uma placa de
controle e com um conjunto de desenvolvimento da MaxStream. O robô possui
também duas placas coloridas em sua parte superior. Essas cores são utilizadas para
que o sistema de seguimento de cor funcione corretamente e também para possibilitar
a distinção entre os robôs ativos, caso exista mais de um, e para determinar a direção
do robô.
Nos próximos itens serão abordados os detalhes da montagem do robô, da
colocação da câmera no ambiente, da colocação das cores de identificação do robô, da
região em que a tarefa será executada e também será definida a tarefa que se deseja
executar.
4.2 Montagem do Sistema e Detalhes de Funcionamento
A montagem da parte física do sistema é bastante simples e apenas alguns
detalhes devem ser vistos com maior atenção. Para se evitar problemas, deve-se
remover todos os obstáculos 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
obstáculos. Outro aspecto levado em consideração é a possibilidade de existirem
objetos que pudem ter suas cores confundidas com as cores dos robôs, fato que poderia
fazer com que o sistema de seguimento de cores perdesse os robôs.
Em relação à câmera, dois aspectos precisam ser vistos com muita atenção.
Primeiro, o foco da câmera deve ser ajustado, tal como explicado no item 3.2, para que
os cálculos de posição sejam feitos corretamente ao converter coordenadas medidas
em pixeis para coordenadas no referencial do mundo, em centímetros. Segundo, a
câmera deve ser afixada a uma altura H conhecida e com uma inclinação também
conhecida, já que o sistema óptico leva em consideração todas essas variáveis para
estimar a correta posição do robô.

43
Todo o controle do sistema é feito pelo computador com dados do sistema
óptico. No início do processo é necessário selecionar as regiões a serem consideradas
pelo sistema de seguimento de cor. Com isso, as cores do robô e também a cor do
ponto alvo devem ser selecionadas para que o sistema possa então considerar essas
cores no momento da execução da tarefa. Para se evitar problemas no sistema de
detecção e seguimento de cor existem dois cuidados básicos que precisam ser
tomados. O primeiro deles é em relação às cores, pois não é recomendável utilizar
cores muito semelhantes. O segundo é em relação à aproximação dos corpos coloridos,
que não devem se aproximar muito para evitar que o sistema óptico junte as cores e
passe então a considerar duas ou mais regiões como sendo apenas uma.
Em relação ao funcionamento do sistema, o sistema óptico adquire as imagens
do ambiente, essas imagens são processadas e então o sistema de seguimento de cor
cuida da movimentação do robô no ambiente de acordo com o objetivo da tarefa.
Nesse caso, os dados relevantes ao controle do robô, velocidade linear e angular, são
transmitidos pelo computador via porta serial, utilizando-se também um módulo XBee
para enviar mensagens em broadcast. Sendo assim, caso houvessem mais robôs no
sistema, todos receberiam as mesmas informações, mas o programa do MSP430 faz a
checagem para saber qual deve executar os comandos recebidos. Isso é possível
porque quando um comando é enviado pelo PC ele vai codificado com a indicação de
qual robô deve executá-lo, e por outro lado, o programa do MSP430 checa se o código
recebido é o mesmo do robô. Se essa informação coincidir, o robô executa os
comandos.
A Figura 20 mostra o ambiente de teste e um robô com suas cores de
identificação. Nessa figura pode-se ver também 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 Computação, em que os robôs devem perseguir uma bola colorida.

44
Figura 20: Ambiente de teste.
4.3 Tarefa Proposta
A tarefa proposta tem como objetivo testar as funcionalidades do sistema e não
necessariamente visa a realização de procedimentos. Testes mais elaborados podem
ser criados e realizados em ambientes e situações mais realistas como aplicações em
chão-de-fábrica ou até mesmo aplicações em que os robôs podem assumir papéis de
guardas ou observadores mantendo-se sempre atentos a um determinado evento.
Para este projeto, a tarefa a ser realizada considera a colocação de um alvo no
ambiente para que o robô o alcance. Para isso, o alvo é identificado com uma
marcação colorida e o robô com duas outras marcações que indicam sua parte frontal
e traseira.
Na tarefa a ser executada, o procedimento inicial é bastante simples. O
ambiente de testes será capturado pela câmera 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 então, as

45
cores dos robô serão também selecionadas e adicionadas ao sistema de seguimento de
cor. O próximo passo é a marcação do alvo, isto é, o ponto em que os robô deve
chegar ao final da tarefa.
Para fins de simplificação, a tarefa proposta considera a reorientação dos robôs
na direção e sentido necessário para que o alvo seja atingido. É importante lembrar que
tanto os robô quanto o alvo são considerados como sendo corpos pontuais
independente de suas dimensões físicas ou da área selecionada na imagem.
A realização de uma tarefa como essa abre caminhos para muitas possibilidades
de aplicações. Com isso, embora pareça simples, essa tarefa permite posicionar robôs
frente-a-frente, empurrar caixas, carregar objetos de um ponto a outro, seguir objetos,
reconhecer marcações e executar tarefas diversas individualmente ou em equipes de
robôs.

46
5 EXPERIMENTO
5.1 Introdução
A fase de testes deste trabalho se mostrou extremamente importante para o
conhecimentos dos problemas, limitações, condições apropriadas aos testes, e também
para reavaliar a possibilidade de implantar um sistema como esse para aplicações
reais.
5.2 Teste e Análise dos Resultados
O que se esperava como resultado era que pelo processamento de imagem o
robô se dirigisse ao alvo após receber as velocidades linear e angular, resultado do
processamento de imagem baseado no seguimento de cor de cor. Eram esperados
alguns problemas devido à iluminação do ambiente. Com relação ao XBee, não eram
esperados problemas visto que trata-se de um dispositivo bastante simples de usar até
mesmo quando ajustado com as configurações padrão de fábrica. Esperava-se também
alguns problemas decorrentes da projeção da imagem, já que existem algumas
imprecisões do sistema físico quando comparado à modelagem matemática. As
principais imprecisões foram notadas quando o robô se afastava muito da câmera.
Nessa condição, a orientação do robô não foi realizada de maneira muito correta, e
apesar do robô chegar ao ponto alvo, não o fazia com a orientação esperada.
Após iniciados os testes ocorreram uma série de problemas. O primeiro deles
foi devido à origem da imagem capturada pela webcam, que foge dos padrões quando
comparada às outras câmeras 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 série de testes e medidas de distâncias foram necessários até que o programa de
seguimento de cor estivesse completamente adaptado a este projeto. O segundo
problema ocorreu devido a uma característica da webcam utilizada. Essa câmera ajusta
automaticamente o brilho dependendo da iluminação do ambiente. Isso trouxe sérios

47
problemas aos testes já que o procedimento inicial do processamento de imagem
considera a captura de um frame, a conversão para HSV, a separação do canal HUE e
então a subtração do fundo para que as cores de identificação do robô e do alvo
possam ser detectadas. Quando a iluminação variava, por menos que fosse, a câmera
reajustava o brilho automaticamente e então o fundo não era mais o mesmo. Isso fazia
com que aparecessem diversas manchas na imagem. Por isso, é muito importante fazer
os testes em superfície fosca e utilizar cores foscas para o robô e para o alvo. Com
todos esses ruídos, 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 à configuração da câmera no
ambiente. Como a câmera capturava o ambiente a uma inclinação de -30º com a
horizontal, e a mesa de testes ficava a cerca de 130 cm abaixo da câmera e a uma
distância horizontal de 180 cm, quando o robô se afastava muito da câmera as regiões
coloridas se tornavam muito pequenas, embora a área da cor selecionada não fosse
redimensionada. Isso fazia com que as regiões se aproximassem muito aumentando as
chances de que as áreas inicialmente selecionadas se fundissem. Devido à distância,
também foi observado que quando as regiões coloridas se tornavam muito pequenas o
sistema de seguimento de cor perdia a cor com facilidade, pois durante o movimento
do robô muitos ruídos na imagem eram gerados e se o robô se aproximasse desses
ruídos 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 execução 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 direção do alvo. Repare que neste último caso, muitos ruídos
surgiram na imagem e a tarefa poderia falhar com relativa facilidade caso o robô
transitasse em regiões com muito ruído.
A respeito dos ruídos gerados na imagem durante a execução da tarefa, algumas
precauções podem ser tomadas a fim de minimizar as chances do sistema de
seguimento de cor falhar. São elas:

48
➢
➢
➢
➢
➢
a estrutura do robô e a superfície em que ele se movimenta devem ser foscas;
deve-se evitar que ocorra variação de luminosidade no ambiente;
vibrações da superfície em que o robô se movimenta e de sua própria estrutura
devem ser evitadas ou minimizadas;
a distância entre o robô e a câmera não pode ser muito elevada, pois a chance
do sistema de seguimento de cor perder as cores ou mesmo perder a precisão ao
inferir a orientação do robô aumenta significativamente com a distância;
os testes mostraram não ser recomendável o uso de webcam em sistemas como
este, pois estas fazem ajuste automático de brilho com a mínima variação de
luminosidade, e nesse momento muitos ruídos são inseridos no sistema.
Com base nos itens descritos acima e levando-se em consideração as condições
em que o teste da Figura 22 foi feito, pode-se atribuir os ruídos capturados nessa
imagem à vibração da estrutura do robô, à vibração da mesa em que ele se
movimentava, e também à variação de luminosidade no momento do teste.
Apesar dos ruídos gerados, a maioria dos testes foi bem sucedida. Ocorreram
problemas apenas nos testes em que os robôs estavam muito distantes da câmera, e
naqueles em que os robôs transitavam nas regiões da imagem com excessivos ruídos
provocados por sobras e por variações intensas de luminosidade. Falharam também os
testes em que as velocidades linear e angular do robô estavam ajustadas para valores
muito elevados. Com isso, através de experimentos chegou-se a valores de V max e ω max
iguais a 50% e 5%, respectivamente.

49
Figura 21: Cores selecionadas com o sistema em repouso.
Figura 22: Cores selecionadas e ruídos gerados com o sistema em
funcionamento.

50
6 CONCLUSÃO
O sistema elaborado neste projeto tem como intuito principal a criação de uma
aplicação capaz de movimentar robôs em um ambiente utilizando-se técnicas de visão
computacional e comunicação sem fio pelo padrão 802.15.4, ZigBee. É também de
interesse que este sistema seja aplicável a tarefas em que os robôs envolvidos possam
trabalhar em cooperação.
Apesar de não ter sido feita uma aplicação envolvendo mais de um robô, o
sistema foi preparado para tornar isso possível. No entanto, uma aplicação com mais
robôs exigiria a criação de uma lógica de execução de tarefas capaz de controlá-los de
modo organizado de acordo com a tarefa a ser executada. Assim, seriam necessárias
várias marcações coloridas no ambiente e tarefas personalizadas para quantidades
diferentes de robôs, isto é, seria necessário a criação de uma estratégia mais complexa
de execução de tarefas.
O padrão ZigBee mostrou-se bastante interessante tanto pela simplicidade de
utilização quando pelas características técnicas que apresenta. A comunicação entre os
dispositivos é feita de maneira bastante simplificada e eficiente. Apesar de que as
instruções do XBee não tenham sido exploradas a fundo, pelo conjunto de instruções
que apresenta pode-se ter uma idéia da versatilidade deste dispositivo. Aplicações
muito complexas podem ser desenvolvidas utilizando-se algumas poucas funções
como checagem de nível de bateria, nível de sinal, captura de informações de outros
dispositivos no campo de alcance e endereçamento de informações a dispositivos
específicos ou em broadcast. Além disso, o ZigBee mostra-se bastante interessante
com relação às técnicas de modulação que utiliza e também em relação à segurança
dos dados que trafegam na rede.
Embora os resultados tenham sido satisfatórios para este projeto, sistemas como
esse precisam ser muito bem desenvolvidos e melhorados para que influências
externas não comprometam tanto seu funcionamento. Com este trabalho conclui-se
que o sucesso do sistema depende de muitos quesitos que vão desde a maneira como a
parte de software é desenvolvida até o tipo de equipamento que se utiliza. Deve-se
também providenciar filtros para imagens capazes de reduzir os ruídos e então

51
aumentar a eficiência e confiabilidade do sistema como um todo. Isso é de extrema
importância, pois nenhum sistema funciona em condições 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 são planejadas para trabalhos futuros. O atual trabalho ainda
não considera sistemas de sensoriamento dos robôs 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 robôs seja prejudicado
dependendo de suas velocidades ou mesmo da mudança de intensidade luminosa no
ambiente, já que a webcam utilizada faz ajustes automáticos diminuindo ou
aumentando o brilho da imagem.
Para trabalhos futuros, além da implementação de sistemas mais robustos
incluindo sensoriamento e melhorias no sistema de seguimento de cor, planeja-se
também um sistema de reconhecimento automático dos robôs ativos na área de alcance
do XBee bem como um sistema capaz de detectar as cores do robôs encontrados sem
que haja necessidade de intervenção humana, tal como é feito no presente trabalho.
Outro objetivo para trabalhos futuros é fazer com que os robôs sempre cheguem ao
alvo com uma orientação específica em relação ao objeto marcado como alvo,
independente das condições iniciais do sistema.
A respeito do sistema de visão como um todo, é também desejável que as
funções de manipulação de imagens possam ser aceleradas, visto que o atual sistema
exige uma performance considerável do computador. Isso ocorre em parte pelo fato de
que algumas das funções 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 criação de sistemas cada vez
mais robustos e mais inteligentes.

52
APÊNDICE A
Para o controle do MSP430 foram feitas algumas adaptações no código
desenvolvido em [14]. As explicações podem ser encontradas em forma de
comentários no corpo do programa.
A principal adaptação feita diz respeito à retirada do controlador integrador que
está presente no programa original. Isso foi feito porque todo o controle dos robôs
passou a ser realizado pelo programa de visão computacional a fim de reduzir a carga
de processamento de cada robô.
Abaixo, segue a listagem completa do código em C.
Arquivo: pwm2_higor.c
#include
#include
#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

----------------- 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);
53
}
}
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)

54
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 )
{

55
// 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
TBCCTL2 = OUTMOD_7; // TBCCR2 in output mode: 7 - reset/set
TBCCTL3 = OUTMOD_7; // TBCCR3 in output mode: 7 - reset/set
TBCCTL4 = OUTMOD_7; // TBCCR4 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;
P1SEL = 0x00;
// P2
P2DIR = 0xFF;
// nao utilizado (NC)
// todos os pinos como E/S
// nao utilizado (NC)

56
P2SEL = 0x00;
// todos os pinos como E/S
// P3
P3DIR = 0xDB; //
P3SEL = 0x3C; //
// P4
P4DIR = 0xFF;
P4SEL = 0x1E;
// P5
P5DIR = 0xFF;
P5SEL = 0x00;
// P6
P6DIR = 0xFF;
P6SEL = 0x00;
// saidas
// P4.1 a P4.4 como TB1-4, outros como E/S
// nao utilizado (NC)
// todos os pinos como E/S
// nao utilizado (NC)
// todos os pinos como E/S
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
}
*/
}

57
APÊNDICE B
O programa utilizado para controle dos motores e seguimento de cor foi
baseado no trabalho desenvolvido pelo PET da Engenharia de Computação da UFES.
No entanto, o trabalho original considera a colocação de uma câmera sobre a região
em que o futebol de robôs é praticado, enquanto que neste trabalho a câmera foi
colocada a uma altura, distância e ângulo com a horizontal conhecidos. Com isso,
passou-se a trabalhar com imagens projetivas e por isso algumas adaptações se fizeram
necessárias.
Na lista abaixo estão todos os arquivos utilizados pelo programa completo com
a indicação se passaram ou não por alterações.
Referência Nome do arquivo Modificação
1 RobotSystem.cpp não
2 SistemaRobotico.h não
3 SistemaRobotico.cpp não
4 ComSerial.h sim
5 ComSerial.cpp sim
6 Camera.h não
7 Camera.cpp não
8 CoordSystem.h não
9 CoordSystem.cpp sim
10 defines.h não
11 DadosVisao.h não
12 DadosVisao.cpp não
13 Tempo.h não
14 Tempo.cpp não
15 BasicProcessor.h não
16 BasicProcessor.cpp não
17 SimpleTracker.h não
18 SimpleTracker.cpp não
19 DoubleTracker.h não
20 DoubleTracker.cpp não
21 TeamTracker.h não
22 TeamTracker.cpp não
23 SistemaVisao.h sim
24 SistemaVisao.cpp sim

A seguir, são listados os arquivos alterados e suas respectivas mudanças.
Repare que a numeração na frente de cada arquivo listado segue a referência acima.
58
4. ComSerial.h
A este arquivo foi adicionada a função read() e a função setBufferInfoSolicita().
A primeira função é para possibilitar a leitura do buffer quando o MSP430 envia dados
informando o código de identificação do robô. A segunda, ajusta o buffer a ser enviado
com valores que o MSP430 interpreta como sendo a solicitação do código interno do
robô. Embora este código esteja completamente funcional, não foi implementado no
programa do MSP430 uma função 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];

59
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 função de leitura, read(), e a função de
ajuste do buffer, setBufferInfoSolicita().
#include
#include "ComSerial.h"
#include
#include
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()

60
{
TCHAR *pcCommPort = TEXT("COM1");
com1 = CreateFile(pcCommPort, GENERIC_READ | GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, 0, NULL);
if (com1 == INVALID_HANDLE_VALUE) {
cout

61
}
}
return 0;
cout

62
{
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 função transform() para que os pontos capturados
da imagem fossem corrigidos adequadamente em relação ao centro da imagem
capturada pela câmera. Neste ponto deve-se levar em consideração que para a webcam
utilizada a origem do sistema é o ponto inferior esquerdo.
#include "CoordSystem.h"
#include
#include
Vec2f::Vec2f()
{
x=0;
y=0;
}
// construtor
Vec2f::Vec2f(float a, float b)
{
x=a;
y=b;

63
}
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

64
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;

65
23. SistemaVisao.h
A aplicação principal foi desenvolvida utilizando-se os arquivos de
SistemaVisao. Aqui foram inseridas novas funções, novas variáveis e novas definições
para a aplicação. Foram inseridas informações sobre a posição da câmera em relação à
mesa, onde os testes foram feitos, e passou-se a comandar a porta serial por esse
arquivo. As novas funções 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 câmera 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;
float alfa;
float teta;
float v;
float w;
float x[10];
float y[10];
float Xc;
float Yc;
float Zc;
float Xm;
float Zm;
float Xd;
float Zd;
float V_MAX;
float W_MAX;
float Xmundo;
float Zmundo;
float ModE;
float xDest;
float yDest;
int infoRobos[10][3];
char statusRobo[10];
protected:
BasicProcessor* basicProc;
CoordSystem *coordSys;
// angulo entre eixo Z e alvo
// angulo da orientacao do robo em relacao a Z
// teta = psi - alfa
// velociade linear
// velocidade angular (giro)
// ponto do robo (3D) projetado na imagem (2D)
// pontos da camera
// pontos do robo no referencial do mundo
// ponto em que se deseja chegar
// usados para conversoes
// modulo do erro
// guarda posicao do alvo em pixels
// guarda o nome do robo e suas velocidades
// linear e angular
// informa se o robo esta ativo ou nao

66
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 mudanças citadas em SistemaVisao.h foram implementadas neste arquivo.
Aqui são descritas as novas funções e também principais adaptações feitas em
addRobots().
A nova função calcTransf() é responsável por fazer a transformação das
coordenadas da imagem, em pixels, para as coordenadas do mundo, em centímetros.
A função calcMove() cuida da movimentação do robô e faz o controle de
execução calculando e enviando as velocidades linear e angular atualizadas. Essa

67
função também envia o comando de parada ao robô quando este se encontra à
distância definida em DIST_SEGURA.
A última, calcAngulo(), calcula o ângulo sempre tomando como referência o
eixo Z positivo. Essa função é utilizada para o cálculo de ψ, ângulo entre o centróide
do robô e o ponto alvo, e de θ, ângulo que fornece a orientação do robô em relação ao
eixo Z. A orientação do robô é medida em relação ao vetor formado entre suas duas
cores de identificação.
Em addRobots(), as principais mudanças foram feitas em relação às
funcionalidades do menu. Com as alterações é possível receber o código dos robôs
ativos, exibir informações tais como velocidade linear e angular atuais, executar a
tarefa e também interrompê-la. Esta tornou-se a principal função de controle de
execução da aplicação proposta neste trabalho.
#include "windows.h"
#include
#include "cvcam.h"
#include "highgui.h"
#include
#include
#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)
{
coordSys = NULL;
basicProc = NULL;
teamTr = NULL;
NP = 0;
NP = 0;
addRobotsMode = 0;
for (int i = 0; i < 10; i++)
statusRobo[i] = 'a';
}
SistemaVisao::~SistemaVisao(void)
{
}
// construtor
// p = parado, a = atividade
// destrutor
Camera* SistemaVisao::iniciaCamera(VideoProcessor *VP)
{
Camera* cam;

68
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;
}
else{
}
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);
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

69
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()
{
float cx1 = 0;
float cx2 = 0;
float cy1 = 0;
float cy2 = 0;
float xPosRobo = 0;
float yPosRobo = 0;
float ExT = 0;
float EyT = 0;
char sinal = '0';
// procedimento principal
// guarda posicao do robo em pixels,
// temporario apenas

70
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);
comando = cvWaitKey(0);
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;

71
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 informações dos robos
printf("\n\nUltimas informacoes dos robos...\n");
if (NP > 0)
{

72
}
else
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]);
}
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
comando = cvWaitKey(500);
} 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

73
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);

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;itransform(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));
}

75
// 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();
xDest = Temp.x - coordSys->Centro.x;
yDest = -(Temp.y - coordSys->Centro.y);
calcTransf(xDest,yDest,ALTURA_ROBO);
// centro entre as duas
// cores do robo, em pixels
// centro do robo - centro
// do sistema de coordenadas
// 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

}
}
{
}
else
{
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));
com->write();
statusRobo[i] = 'p';
// escreve na porta serial
// 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...");
// 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));
com->write(); // escreve na porta serial
}
// guarda informacoes dos robos
infoRobos[i][0] = v;
infoRobos[i][1] = w;
infoRobos[i][2] = i;
76
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;
}

77
}
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;

78
REFERÊNCIAS BIBLIOGRÁFICAS
1. C. Soria, R. Carelli, R. Kelly, J. M. I. Zannatha. Control de Robots Cooperativos por
Medio de Vision Artificial. XVI Congreso de la Asociación Chilena de Control Automático,
2004.
2. R. Kelly, R. Carelli, J. M. Zannatha, C. Monroy. Control de una pandilla de robots
móviles para el seguimiento de una contelación de puntos objetivo. VI Congreso
Mexicano de Robótica, 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. Bragança. Estratégias para Deslocamento de Cargas Através de Cooperação de
Robôs Móveis a Rodas. Dissertação de Mestrado, UFES, Vitória, ES, 2004.
6. R. F. Vassallo. Cooperação de Robôs baseada em Visão Omnidirecional. Projeto
PIBIC 2006-2007, UFES, Vitória, ES, 2006.
7. Inovação Tecnológica. Robôs 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 Estratégia de Navegação para Robôs Móveis em Ambientes
Interiores. Dissertação de Mestrado, UFES, PPGEE, Vitória, ES, 1998.
9. E. Zambon. Uma Plataforma para Desenvolvimento de Robôs de Baixo Custo com
Alta Capacidade Computacional – IROBOT. Projeto de Graduação, UFES, Vitória,
ES, 2004.
10. F. Pereira. Microcontroladores MSP430 – Teoria e Prática. 1 a Edição, 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 Aplicações. Relatório
apresentado à disciplina de Sistemas de Telecomunicações, UFES, Vitória, ES, 2006.
14. C. C. Gava. Controle de Formação de Robôs Móveis Baseado em Visão
Omnidirecional. Tese de mestrado, UFES, Vitória, ES, 2007.
15. MFSM. CAMSHIFT Experiments. Visitado em 23/12/2007.
http://mfsm.sourceforge.net/MFSM_0.7/tutorials/Camshift.html