TCC Rov

CENTRO UNIVERSITÁRIO DAS FACULDADES
ASSOCIADAS DE ENSINO
Campus SÃO JOÃO DA BOA VISTA
Curso de Engenharia da Computação
COMUNICAÇÃO E CONTROLE DO ROV SUBAQUÁTICO
Gustavo Soquetti dos Reis

Mateus Felipe Ramos
SÃO JOÃO DA BOA VISTA

2010
Gustavo Soquetti dos Reis
Mateus Felipe Ramos
Trabalho apresentado a disciplina de

Orientação de Projeto de Conclusão de Curso
II do programa de Graduação em Engenharia
da Computação do Centro Universitário das
Faculdades de Ensino – Campus São João da
Boa Vista.
Orientador: Prof. Ramiro Romankevicius Costa
SÃO JOÃO DA BOA VISTA

2010
2
Trabalho apresentado a disciplina de

Orientação de Projeto de Conclusão de Curso
II do programa de Graduação em Engenharia
da Computação do Centro Universitário das
Faculdades de Ensino – Campus São João da
Boa Vista.
Orientador: Prof. Ramiro Romankevicius Costa
Prof. M.Sc. Ramiro Romankevicius Costa – Orientador
Prof. M.Sc. Henrique Antônio Mielli Camargo – Examinador
Prof. Dr. Helder Anibal Hermini – Examinador
São João da Boa Vista, 10 de dezembro de 2010.
3
DEDICATÓRIA
Gustavo Soquetti dos Reis:

“Dedico a todos que de forma direta ou indireta contribuíram para a conclusão deste
trabalho. A minha família pelo apoio e confiança, aos professores por sua dedicação
e compreensão durante a graduação e principalmente a todos os amigos que
sempre estiveram presentes”
Mateus Felipe Ramos:

“Agradeço aos meus familiares pelo amor, carinho e principalmente por acreditarem
em mim, e também aos meus amigos por todos os momentos juntos”
4
AGRADECIMENTOS
Ao nosso professor orientador Ramiro Romankevicius Costa, pela paciência,

dedicação e prontidão para fornecer as informações necessárias para o bom
caminhar de todo desenvolvimento teórico e prático deste projeto.
Aos professores Helder e Henrique, pela ajuda extra ao nos fornecer algumas
dicas e conhecimentos importantes para a conclusão da elaboração deste sistema
eletrônico.
A todos os professores das disciplinas lecionadas durante o curso, pela
dedicação em nos fornecer o devido conhecimento para nossa formação.
A nossos amigos e familiares pela compreensão, ajuda e os bons momentos
proporcionados durante nossa vida.
5
RESUMO
Um ROV (Remotely Operated Vehicle) é um veículo controlado remotamente,

que neste projeto permitirá a observação remota de um ambiente subaquático de
baixa profundidade. A ligação entre o veículo e a superfície é assegurada por um
cordão umbilical que permite a comunicação bidirecional, assim como o transporte
de energia para o veículo. A utilização do ROV permite a operação a maiores
profundidades e durante um período mais prolongado do que seria possível com o
recurso de mergulhadores. Além disso, é possível a operação em águas
contaminadas que representa um risco a vida humana.
Palavras Chave: ROV – Cordão Umbilical – Comunicação
6
ABSTRACT
An ROV (Remotely Operated Vehicle) is a remotely controlled vehicle, that

this project will allow remote observation of a low depth underwater environment. The
connection between the vehicle and the surface is ensured by an umbilical cord that
allows bidirectional communication, as well as the transport of energy for the vehicle.
The use of ROV enables greater depths and operation during a longer period than is
possible with divers. In addition, it is possible the operation in contaminated water
that poses a risk to human life.
Keywords: ROV - Umbilical Cord - Communication
7
LISTA DE FIGURAS
Figura 1: Modos de comunicação Simplex, Half-Duplex e Full-Duplex................................................. 12
Figura 2: Estrutura e Pinagem do conector DB9 de transmissão.......................................................... 14
Figura 3: Formatação de uma transmissão de 11 bits assíncronos ...................................................... 14
Figura 4: Sinal elétrico do padrão RS-232 ............................................................................................. 15
Figura 5: Fluxograma do módulo de interface do usuário.................................................................... 12
Figura 6: ROV e Modulo de controle da ferramenta............................................................................. 12
Figura 7: Fluxograma do módulo de controle de ferramenta............................................................... 12
Figura 8: Fluxograma do módulo de controle dos propulsores ............................................................ 12
Figura 9: Exemplo de mensagem enviada seguindo o código de Baudot............................................. 12
Figura 10: Sinal elétrico do caracter ‘P’ (10110 binários) ..................................................................... 24
Figura 11: Canais independentes de comunicação do modo Full-Duplex ............................................ 26
Figura 12: Exemplo de temporização para o tráfego de bits de dados ................................................ 27
Figura 13: Exemplo de mensagem enviada pelo tipo de comunicação assíncrono.............................. 28
Figura 14: Regulador de tensão do circuito .......................................................................................... 31
Figura 15: Funcionamento do Driver MAX232...................................................................................... 33
Figura 16 Pinagem do microcontrolador PIC 16F877A ......................................................................... 34
Figura 17: Figura do microcontrolador apto para receber mensagens de uma porta serial................ 35
Figura 18: Funcionamento do CI L298................................................................................................... 37
Figura 19: Execução do segundo e terceiro comando de controle da Tabela 2 ................................... 39
Figura 20: Estrutura interna do CI L298 ................................................................................................ 39
Figura 21: Ponte H completa................................................................................................................. 40
Figura 22: Exemplo de um ciclo ativo em um determinado período de tempo ................................... 41
Figura 23: Exemplo de modulação para os motores propulsores ........................................................ 41
Figura 24: Método getPortasIO() .......................................................................................................... 45
Figura 25: Método getConexao() .......................................................................................................... 45
8
Figura 26: Método getConexaoCom()................................................................................................... 46
Figura 27: Método setExecutaComando() ............................................................................................ 47
Figura 28: Método getComponentWebCam() ...................................................................................... 48
Figura 29: Interface de configuração dos parâmetros de controle ...................................................... 50
Figura 30: Método setParametrosBean().............................................................................................. 52
Figura 31: Método actionPerformed() .................................................................................................. 53
Figura 32: Interface Visual..................................................................................................................... 55
Figura 33: Linhas de configurações do sistema do microcontrolador .................................................. 57
Figura 34: Loop Eterno .......................................................................................................................... 59
Figura 35: Pinagem dos controles direcionais dos motores ................................................................. 60
Figura 36: Configuração da comunicação serial do componente COMPIM ......................................... 64
Figura 37: Porta serial virtual encontrada pela interface visual do computador externo.................... 64
9
LISTA DE TABELAS
Tabela 1: Especificações dos motores do protótipo ............................................................................. 29
Tabela 2: Controle analógico dos motores ........................................................................................... 38
Tabela 3: Configuração dos fusíveis do microcontrolador.................................................................... 57
10
LISTA DE ABREVIATURAS E SIGLAS
API Application Programming Interface

ASCII American Standard Code for Information Interchange
BPS Bits Por Segundo
CI Circuito Integrado
EE Enterprise Edition
EIA Eletronic Industries Association
I/O Input/Output
IBM International Business Machines
IDE Integrated Development Environment
JMF Java Media Framework
OO Orientado A Objeto
PC Personal Computer
PCI Placa de Circuito Impresso
PWM Pulse Wildth Modulation
RD Receive Data
ROV Remotely Operated Vehicle
RS Recomended Standard
TD Transmit Data
TTL Transistor-Transistor Logic
UML Unified Modeling Language
USB Universal Serial Bus
VS Supply Voltage
VSS Logic Supply Voltage
11
SUMÁRIO
1. INTRODUÇÃO .............................................................................................................................. 13
1.1.JUSTIFICATIVA.............................................................................................................................. 15
1.2. OBJETIVOS .................................................................................................................................. 16
1.2.1. Objetivo Geral....................................................................................................................... 16
1.2.2. Objetivo Especifico .................................................................................................................. 16
3. MÉTODOS E TÉCNICAS.............................................................................................................. 22
3.1. COMUNICAÇÃO ........................................................................................................................... 22
3.1.1. Comunicação Serial............................................................................................................. 22
3.1.2. Padrão RS-232..................................................................................................................... 24
3.1.3. Temporização ....................................................................................................................... 25
3.1.4. Modo de Transmissão Serial.............................................................................................. 25
3.1.5. Tipo de Transmissão Serial ................................................................................................ 26
3.2. CIRCUITO CONTROLADOR........................................................................................................ 29
3.2.1. Regulador de Tensão .......................................................................................................... 31
3.2.2. Driver MAX232 e Microncontrolador PIC 16F877A ........................................................ 32
3.2.3. Circuito Integrado L298 ....................................................................................................... 35
3.2.4. Ponte H.................................................................................................................................. 37
3.2.5. PWM ...................................................................................................................................... 40
3.3. PROGRAMA DO COMPUTADOR EXTERNO ............................................................................. 42
3.3.1. API Comm ............................................................................................................................. 44
3.3.2. API JMF ................................................................................................................................. 47
3.3.3. Interface de Configuração dos Parâmetros de Controle................................................ 49
3.3.4. Classe ArqDat....................................................................................................................... 53
3.3.5. Interface Visual Principal..................................................................................................... 54
3.4. PROGRAMA DO MICROCONTROLADOR ................................................................................. 56
3.4.1. Controle Direcional .............................................................................................................. 59
3.4.2. Controle de Velocidade ....................................................................................................... 61
4. TESTES......................................................................................................................................... 63
5. CONCLUSÂO................................................................................................................................ 66
5.1. TRABALHOS FUTUROS.............................................................................................................. 67
BIBLIOGRAFIA..................................................................................................................................... 68
APÊNDICE A - CIRCUITO CONTROLADOR ...................................................................................... 73
APÊNDICE B - DIAGRAMA DE CLASSE ........................................................................................... 74
APÊNDICE C - PROGRAMA DO COMPUTADOR EXTERNO ........................................................... 75
APÊNDICE D - PROGRAMA DO MICROCONTROLADOR................................................................ 99
APÊNDICE E - SIMULAÇÃO ............................................................................................................. 101
12
INTRODUÇÃO
Este trabalho consiste em desenvolver um sistema de comunicação, para o

controle de um ROV (Remotely Operated Vehicle) em ambiente subaquático.
A comunicação será composta por um cordão umbilical de cabos preparados

para alimentar e transmitir sinais na forma serial diretamente as placa PCI (Placa de
Circuito Impresso), acoplada a estrutura do ROV.
A comunicação em serie também conhecida como RS-232 é um padrão para

comunicação de dados definido pela EIA (Eletronic Industries Association), utilizada
para conectar modems, mouses, impressoras e outros equipamentos de hardware.
Esta possui três modos de comunicação distintos, Simplex, Half-Duplex e Full-
Duplex. No modo Simplex o fluxo de transmissão flui somente em um sentido, ou
seja, um dispositivo apenas transmite e outro recebe. Nos modos Half-Duplex e Full-
Duplex o fluxo de dados pode fluir nos dois sentidos, com uma única diferença, na
comunicação Half-Duplex não é transmito o sinal simultaneamente, ou seja, um
dispositivo transmite e o outro recebe, e vice-versa, diferente da Full-Duplex, onde
ambos os dispositivos podem transmitir e receber dados ao mesmo tempo por duas
linhas de comunicação independentes, TX e RX. (CANZIAN, 2001) A Figura 1
esclarece essa diferenciação.
Figura 1: Modos de comunicação Simplex, Half-Duplex e Full-Duplex
Fonte: Do Autor
Os três modos de comunicação descritos anteriormente podem ser utilizados

em dois tipos diferente de transmissão que o padrão RS-232 nos proporciona, tipo
síncrono e assíncrono. No sistema de transmissão assíncrono que é considerado a
melhor para o sincronismo entre transmissores e receptores de dados de baixo
porte, o sinal transmitido (Figura 2, pino 3) é precedido e finalizado por bits,
respectivamente Start Bit e Stop Bit (Bit de inicio e bit de encerramento) como
exemplificado na Figura 3. (MESSIAS, 2005)
13
Figura 2: Estrutura e Pinagem do conector DB9 de transmissão
Fonte: Rogercom, 2005
Figura 3: Formatação de uma transmissão de 11 bits assíncronos
Existem três tipos de RS-232 (A, B e C), cada um define tensões diferentes
para bits em 1 e bits em 0. O tipo mais utilizado é o RS-232C, que define a voltagem
do bit ligado entre -3V e -12V e a tensão do bit desligado entre +3V e +12V(Figura
4). A especificação define que esse sinal só é viável para distancias de até 8 metros,
para distâncias superiores é necessário outros protocolos. (PUCRS, 2005)
14
Figura 4: Sinal elétrico do padrão RS-232
O interfaceamento entre um microcontrolador e um microcomputador é

convencionalmente realizado pelo padrão RS-232, pois diferente da comunicação
paralela que é necessário um fio para cada bit, na comunicação serial apenas um fio
seria suficiente para comunicação de dados o que facilitaria a construção do cordão
umbilical. (TORRES, 2008) A velocidade da porta serial é freqüentemente expressa
em bits por segundo (bps). Isso representa o numero de marcas que podem ser
enviados em um segundo. Velocidades comuns são 2400, 4800 e 9600 bps (
DEMAMANN, 2001).
A placa PCI para o controle dos motores poderá ser projetada após a
definição da comunicação entre o PC (Computador Pessoal) e o ROV. Como o
objetivo da comunicação implica simplesmente em transmitir dados para o
dispositivo, o modo de comunicação Simplex transmitindo o sinal serial assíncrono
atende perfeitamente as necessidades de comunicação deste projeto.
1.1. Justificativa
Os ROVs tiveram sua importância comprovada na exploração dos mares,

sendo muito utilizados em pesquisas submarinas na busca de destroços, pesquisa
arqueológica e em especial na indústria do petróleo, onde é usado principalmente na
operação de poços, posicionamento, construção e inspeção, acompanhamento do
trabalho de mergulhadores, etc.
15
Nos dias atuais o ROV se tornou uma ferramenta muito importante na
extração de petróleo. Possuindo múltiplas finalidades, desde a pesquisa e
prospecção, manutenção dos dutos, até a exploração do fundo do mar. (SILVA,
2002)
1.2. Objetivos
1.2.1. Objetivo Geral
Projetar e montar um protótipo ROV de submersão em águas de baixa

profundidade, controlado por computador.
1.2.2. Objetivos Específicos
O projeto será divido em três partes distintas: Propulsão, Estrutura e

Comunicação/Controle, das quais abordaremos a ultima neste trabalho,
desenvolvendo um sistema de comunicação e controle para o ROV subaquático.
16
2. REVISÂO BIBLIOGRAFICA
No mundo tem sido grande a tendência de automatização e robotização dos

processos industriais. Na Indústria do Petróleo, além de uma tendência, a
robotização é uma necessidade determinada pela impossibilidade da presença do
homem em altas profundidades. (FRANKLIN, 2002)
Desde o final dos anos 90 o mercado de exploração do petróleo tem sido uma
das principais fontes de investimento e desenvolvimento de novas tecnologias no
Brasil. Nesse contexto, destaca-se principalmente o aprimoramento dos materiais,
equipamentos e dos procedimentos adotados no conjunto de processos necessários
para a exploração do petróleo. (PONTES, 2002)
O ROV surgiu como uma solução para esta e outras necessidades, podendo
ser definido como um Veículo de Operação Remota não tripulado, composto por um
sistema de Comunicação de Dados entre a superfície e o mesmo através de um
cordão umbilical.
Com a descoberta do pré-sal o mercado de ROVs esta super-aquecido no
Brasil, criando expectativas de grande lucro.[b] As reservas em águas profundas
geraram uma alta demanda, não só de equipamentos, mas também de profissionais
que operem esses veículos, baseados nisso grandes e pequenas empresas estão
investindo em tecnologia e na formação especializada de diversos profissionais das
áreas de eletrônica, mecânica, eletro-mecânica ou eletrotécnica.(NICOMEX, 2006)
Em outras áreas tem se tornado um forte aliado, podendo ser utilizado em
pesquisas submarinas em geral, inclusive na busca por destroços e pesquisa
arqueológica embaixo d’água. (TECNOPEG, 2010)
Na área militar pode ser usado em missões como mapear uma área para
determinar se há minas, ou para monitorar uma área protegida (como um porto) para
se precaver de ataques de submarinos inimigos.(SILVA, 2010)
Alguns cientistas fazem uso de ROVs para estudar lagos, o oceano, e o piso
oceanico. Uma variedade de sensores podem ser empregados nos ROVs para
medirem : a concentração de vários elementos ou compostos, a absorção ou
reflexão da luz, e a presença de vida microscópica.(RRC, 2010)
Estes veículos são alimentados eletricamente e controlados via cordão
umbilical, eles são dirigidos e navegam na água através de comandos realizados por
17
operadores, os movimentos de navegação são causados pela atuação de
propulsores hidráulicos ou elétricos. (VALERIO, 2010)
Os ROVs podem ser divididos em duas classes: observação e de intervenção.
Os de observação são, geralmente, menores que um metro cúbico e não dispõem
de braços, basicamente são compostos por câmeras de vídeo que se movimentam.
Os veículos de intervenção costumam ser maiores, em torno de dois metros de
altura por três de comprimento e chegam a pesar mais de três toneladas. Estes
ROVs possuem braços manipuláveis para que se possam agarrar objetos, operarem
válvulas e quase todas as operações que um mergulhador faria em águas mais
rasas, tendo capacidade para carregar uma grande quantidade de ferramentas para
intervenções nos poços e equipamentos submarinos. (TECNOPEG, 2010)
O controle e a comunicação entre o operador e o veiculo são ferramentas
extremamente importantes para o sucesso das missões onde os ROVs são usados
como ferramentas principais. Atualmente pode-se observar uma grande quantidade
de universidades que desenvolvem tecnologias para criar e/ou aperfeiçoar as
ferramentas já existentes para estes veículos.
O British Columbia Institute of Technology tem seu sistema de controle
eletrônico distribuído entre três módulos separados: Módulo de interface de usuário,
Módulo de controle de ferramenta e Módulo de controle do propulsor.(B.C.I.T., 2005)
Cada módulo contém um microcontrolador Atmel AVR ATmega644 em uma
placa de circuito impresso personalizada. O GNU Compiler Collection suporta a
arquitetura AVR para que programação possa ser feita em alto nível de linguagens.
A capacidade de programar o ROV em uma linguagem de alto nível permite
alterações mais rápidas e facilitam o processo de encontrar e reduzir erros na
programação.
O módulo de interface do usuário está localizado nos controles na superfície.
Ele recebe os comandos do dispositivo de entrada, um joystick, transforma em
instruções para o ROV e envia as instruções através do protocolo EIA485. Seu
funcionamento é descrito na Figura 5.
18
Energia Inicializa Coletar Entrada Calcular a Enviar instruções s
r distribuição pelo EIA485
do impulso
Figura 5: Fluxograma do módulo de interface do usuário

Fonte: The British Columbia Institute of Technology
O Módulo de controle da ferramenta situa-se na frente do ROV (Figura 6). Ele

recebe as instruções da superfície através do cordão umbilical, envia instruções para
os quatro propulsores pelo módulo de controle de propulsor, via SPI (Serial
Peripheral Interface) ele controla as câmeras, servos e o propulsor de acordo com
as instruções restantes. Um diagrama da sua operação é mostrado na Figura 7:
Figura 6: ROV e Modulo de controle da ferramenta

Não
Inicializa Verifica EIA485 Mensagem

Energia
r de Inicio?
Sim
Ler a Transmitir Regular Regular PWM Regular a

Mensagem instruções ao servo para um posição da
propulsor PWM propulsor câmera
Figura 7: Fluxograma do módulo de controle de ferramenta

19
O módulo de controle do propulsor está localizado na parte traseira do ROV.
Ele recebe instruções do módulo de controle de ferramenta via SPI e produz sinais
PWM para os controladores motores de acordo com as instruções. Sua operação é
descrita na Figura 8:
Energia Inicializa Verificar SPI

r
Sim
Mensagem Ler a Regular PWM
de Inicio? Mensagem - propulsor
Não
Figura 8: Fluxograma do módulo de controle dos propulsores
Pode-se observar a importância do cordão umbilical no processo de

comunicação. Em se tratando de ROV o "Umbilical" é o cabo que o liga a plataforma,
sonda ou navio. Assim como no ser humano o umbilical do ROV é um elo vital
fornecendo a necessária energia e comunicação entre as partes componentes do
sistema, por ele trafegam sinais elétricos, através de cabos elétricos, e sinais
eletrônicos através de cabos de dados como a fibra óptica, o par trançado e o cabo
coaxial.
A maioria dos ROVs em uso hoje em dia são alimentados por baterias
recarregáveis (íons de lítio, de polímero de lítio, níquel metal hidreto, etc.). Alguns
veículos usam baterias primárias que oferecem talvez o dobro da resistência - a um
custo substancial extra por missão. Alguns dos veículos de maiores dimensões são
alimentados por células de combustível. O que torna possível diminuir a bitola do
cordão umbilical, pois não será necessário utilizar um cabo para a alimentação
(GITIRANA, 2005).
As formas de alimentação não apresentam vantagens e nem desvantagens,
pois dependem do tamanho do veiculo e a quantidade de ferramentas equipadas no
veiculo, no caso de um ROV acadêmico não se faz necessário que a bateria fique na
estrutura do veiculo, evitando assim o sobrepeso do veiculo e reduzindo o custo.
Entre os cabos de dados podemos destacar o de par trançado, ele é
constituído por quatro pares de cabos entrelaçados, o entrelaçamento dos cabos
20
cria um campo eletromagnético que oferece uma razoável proteção contra
interferências externas.
Os cabos podem ser blindados ou não, cuja única diferença entre eles é que
os cabos blindados além de contarem com a proteção do entrelaçamento dos fios
possuem uma blindagem externa, sendo mais adequados a ambientes com fortes
fontes de interferências, como grandes motores elétricos e estações de rádio que
estejam muito próximas. Outras fontes menores de interferências são as lâmpadas
fluorescentes, cabos elétricos quando colocados lado a lado com os cabos de rede e
mesmo telefones celulares muito próximos dos cabos.
Este tipo de cabo permite uma distância máxima entre os pontos de até 100
metros, os cabos do tipo par transado são mais baratos que os outros tipos de cabo
e sua velocidade máxima é de 100 mbps. O que atende as necessidades de
transmissão de dados de um ROV acadêmico. (ALEX, 2001)
A seguir, nos próximos capítulos utilizaremos conceitos abordados para
projetar o sistema de controle e comunicação entre o ROV e o operador.
21
3. MÉTODOS E TÉCNICAS
3.1. Comunicação
Nos dias atuais os sistemas de comunicação aparecem em constante

evolução e desenvolvimento, sempre buscando a melhor forma em questão de nível
físico, eficiência e velocidade de transmissão. A partir do que o próprio título deste
trabalho descreve “Comunicação e Controle”, o inicio das projeções parte da escolha
do melhor tipo de comunicação viável para as expectativas deste projeto, em
seguida, a partir desta, desenvolver os controladores, que são o circuito eletrônico e
os softwares utilizados.
Os computadores integram em sua estrutura diversos tipos de comunicação,
como por exemplo, paralela, serial, USB (Universal Serial Bus), Ethernet,
Phone/Modem e outras. Todas elas possuem diferenças de comunicação, que varia
desde os softwares que as utilizam, estruturas de hardwares, especificações,
velocidade, alimentação, etc. A partir destas estruturas diversas de comunicação,
temos um universo extenso na forma de uso de cada uma delas na área robótica
(FRANCO, 2006).
A comunicação escolhida para o desenvolvimento deste projeto é a I/O
(Input/Output) serial. Pelo fato de ser uma comunicação tradicional na área
computacional, ela possui um extenso suporte sobre hardwares e softwares, e
também uma velocidade de transmissão consistente para um sistema de
comunicação de pequena e média distância entre periféricos.
Os detalhes e características funcionais da comunicação serial serão
descritas nos subitens.
3.1.1. Comunicação Serial
A comunicação convencional em série também conhecida como RS-232

(Recommended Standard) é um padrão para comunicação de dados definido pela
EIA (Eletronic Industries Association), utilizada para conectar mouses, impressoras,
microcontroladores e outros equipamentos de hardware. Diferentemente da
comunicação paralela, a comunicação serial utiliza um único canal de comunicação
para envio, e outro para recepção de dados, onde ela teve seu marco inicial com a
22
invenção do telegrafo e em seguida um grande desenvolvimento com a invenção do
teletipo (Teletype) pelo francês Jean Maurice Émile Baudot, em 1871, surgindo
assim o código de Baudot (ROGERCOM, 2006).
O código de Baudot possuía dois subconjuntos de códigos. Um deles era o
conjunto das letras, chamadas por ele de LTRS, criado para codificar as letras do
alfabeto, e FIGS criados para codificar símbolos, pontuação e dígitos numéricos,
onde FIGS é a abreviação de Figuras. Um caracter era representado por um sistema
de 5 dígitos binários, 0 ou 1, onde 1 chamava-se marca (Mark) e 0 chamava-se
espaço (Space).
Após o recebimento de forma assíncrona o teletipo utilizava um sistema com
5 perfurações que representavam os 5 bits recebidos, utilizando a perfuração do
papel para representar a marca e um espaço em branco para representar o espaço.
Para distinguir uma palavra, o inicio do sinal era representado pelo seu código
identificador, LTRS ou FIGS, como podemos ver no exemplo a seguir da Figura 9
(M.V.I., 2002).
Figura 9: Exemplo de mensagem enviada seguindo o código de

Baudot
Fonte: Do autor
Na transmissão de caracteres, o sinal da marca era representado pela

presença de corrente elétrica e o espaço pela ausência de corrente (ROGERCOM,
2006).
23
Figura 10: Sinal elétrico do caracter ‘P’ (10110 binários)
Como podemos observar na Figura 10, temos a representação de um

caracter com os 5 bits do código de Baudot. Outra característica apresentada e que
deu origem aos tipos e padrões de comunicação dos dias atuais, é o Start
representado pelo espaço e Stop representado pela marca, estes serviam para
serem interpretados pelo equipamento receptor das informações, para definir o inicio
e fim de cada caracter (ROGERCOM, 2006).
Baseando-se neste sistema de Baudot (mark, space, start bit, stop bit e bits de
dados) de transmissão e interpretação de dados, que o padrão computacional RS-232
foi desenvolvido e tornou-se o padrão atual de comunicação, sendo utilizados por todos
os tipos de equipamentos modernos, e pelo sistema de controle desenvolvido para este
protótipo.
3.1.2. Padrão RS-232
O padrão RS-232 foi criado no inicio da década de 1960, a partir das idéias de
telefonia vistas anteriormente. Ela especifica as tensões, temporizações e funções
dos sinais, um protocolo para troca de informações, e as conexões mecânicas. Com
o passar dos anos foram aparecendo varias versões da RS-232, como por exemplo,
os tipos RS-232A, RS-232B, RS-232C, RS-232D e tipo RS-232E, onde esta é a
mais recente sendo lançada em 1991 (CANZIAN, 2005).
Cada uma define tensões diferentes para bits em 0 e 1, que variam de -3V e -
25V para o bit em nível baixo (Space), e +3V a +25V para o nível alto (Mark)
24
(PUCRS, 2005). Algumas interfaces seriais nos computadores atuais fornecem -12V
e +12V, mas suportam mínimas de -25V e +25V (ROGERCOM, 2006).
3.1.3. Temporização
Uma característica fundamental da comunicação RS-232 é a velocidade,

onde esta é expressa em bits por segundo, ou simplesmente bps. Isso representa o
numero de marcas que podem ser enviados em um segundo. Velocidades comuns
são 300, 1.200, 2.400, 4.800, 9.600 (velocidade padrão definido pela EIA), 19.200 e
115.200, que é a velocidade limite imposto pela IBM (International Business
Machines) para maior parte dos hardwares (CANZIAN, 2005) (PUCRS, 2006).
Embora a velocidade para uma comunicação entre periféricos que estejam a uma
distância de 10 metros, seja limitada para 20.000bps [23].
Com base nesta informação, será utilizada para estabelecer a velocidade de
comunicação entre o protótipo e a superfície, a taxa padrão mais aproximada do
valor de 20.000bps, que é a de 19.200bps, partindo da definição que o cordão
umbilical do ROV terá 10 metros de comprimento.
Esta velocidade é denominada Baud Rate (Taxa de Baudot), ou simplesmente
baud (CANZIAN, 2005).
3.1.4. Modo de Transmissão Serial
A comunicação serial possui três modos de comunicação distintos, modo

Simplex, Half-Duplex e Full-Duplex, onde este último é o utilizado pelo padrão RS-
232.
O modo de comunicação Full-Duplex representa uma linha de comunicação mais
evoluída onde podemos transmitir informações de um modo síncrono, ou seja, enviar e
receber informações ao mesmo tempo. Como por exemplo, um telefone convencional,
onde duas pessoas podem se comunicar tranquilamente ao mesmo tempo sem
restrições, diferentemente de um rádio Walk-Talk, que possui somente um canal de
comunicação (ROGERCOM, 2006) (CANZIAN, 2005) (PUCRS, 2006).
25
Figura 111: Canais independentes de comunicação do modo Full-Duplex
Os canais de transmissão utilizados pelo padrão RS-232 são, RD (Receive

Data) para a recepção (Pino 2) e TD (Transmit Data) para o envio de dados (Pino 3),
conforme estrutura do conector DB9 da porta serial (COM) de um computador,
apresentada na Figura 2 do capitulo 1 (PUCRS, 2006).
3.1.5. Tipo de Transmissão Serial
Para que uma transmissão serial ocorra, é necessário que o emissor e o

receptor estejam em total sincronismo. Normalmente dados seriais não são enviados
de maneira uniforme através de uma linha de transmissão, ao contrario disso,
pacotes com informações são enviados seguidos de uma pausa. Assim são
enviados os pacotes de dados binários. O circuito receptor de dados deve saber
exatamente o momento em que um pacote começa e quanto tempo decorre entre
estes bits (ROGERCOM, 2006).
Quando esta temporização for conhecida pelo receptor, pode-se dizer que
está sincronizada, assim tornando-se possível à transferência de dados. Existem
dois tipos de transmissão entre a comunicação serial, são eles os tipos síncrono e
assíncrono, onde o tipo de comunicação utilizada pelo padrão RS-232 deste projeto
é o assíncrono.
No tipo de transmissão assíncrono, a informação trafega por um canal único.
Tanto o emissor quanto o receptor devem ser configurados inicialmente para que a
comunicação seja estabilizada. Um oscilador no receptor gera um sinal temporizador
que é igual ao do receptor. Necessariamente, esta comunicação pode possuir 10 ou
11 bits, dos quais 8 deles constituem os dados. Diferentemente da comunicação
síncrona, esta é inicializada pelo sinal lógico baixo (0), que representa o Start Bit e é
finalizado pelo nível lógico alto (1) que representa o bit de encerramento do pacote
de dados, Stop Bit. O Start bit inicializa um temporizador interno do receptor
26
avisando que a transmissão começou e que serão necessários pulsos de
temporização (clock) (CANZIAN, 2005).
Na Figura 12 a seguir, podemos observar que o emissor e o receptor
possuem relógios temporizadores independentes.
Figura 12: Exemplo de temporização para o tráfego de bits de dados
O bit que fica entre o ultimo bit de dados e o Stop Bit é o bit de paridade. Este
bit é utilizado apenas no tipo de comunicação assíncrona para servir como uma
solução primaria a nível físico para detectar a ocorrência de erros na transmissão de
dados. Para definir se houve algum erro na transmissão o contador dos bits do
receptor verifica se a quantidade recebida é par ou ímpar. Por exemplo, se
definirmos nas configurações do receptor e emissor o bit de paridade sendo como
par, a soma de todos os bits mais o bit de paridade deve ser par para ser
considerada uma transmissão correta, caso os dados recebidos sejam ímpar, isso
significa que a informação sofreu alguma modificação ao decorrer da transmissão
(ROGERCOM, 2006) (CANZIAN, 2005) (PUCRS, 2006).
Na Figura 13 á seguir, será apresentado um exemplo de uma mensagem de
dados enviado pelo tipo de comunicação assíncrono.
27
Figura 13: Exemplo de mensagem enviada pelo tipo de comunicação assíncrono
O bit de paridade pode ser configurado como par, ímpar ou nenhum,

dependendo do que necessariamente definimos e projetamos para uma transmissão
de dados entre determinados componentes de hardware. Neste projeto de controle o
bit de paridade não será utilizado.
Pode ser observada na Figura 13, a existência de um calculo que mostra que
o valor do tempo (T) é igual a 104,2us. Este é o intervalo de tempo que o receptor
terá para identificar o estado do sinal, marca ou espaço, onde este tempo é o
mesmo utilizado pelo transmissor. O tempo de cada bit pode ser conhecido dividindo
o número 1, que representa um bit, pela taxa de baud configurada para a
transmissão (ROGERCOM, 2006). Para este valor acima o calculo seria
representado por:
T = 1 / baud = 1 / 9.600 (Taxa padrão da IBM) = 104,2us
Conforme citado do subitem 3.1.3, o valor de baud pré-determinado para a

comunicação entre o protótipo e o computador da superfície é de 19.200bps. A partir
deste número, calculamos o valor do tempo em que será realizado o sincronismo
dos bits de controle enviados para o ROV, que será de:
T = 1 / Baud = 1 / 19.200 = 52us
28
Se cada marca ou espaço pode ser reconhecido pelo receptor em um tempo
T de 52us, e definimos que a mensagem de controle enviada para o protótipo não
possuirá o bit de paridade, contendo assim uma quantidade total de 10 bits, o tempo
estimado para uma mensagem ser recebida completamente será:
Tempo Total = Bits * T = 10 * 52us = 0,00052s
3.2. Circuito Controlador
O primeiro passo para o desenvolvimento de toda comunicação e controle

deste projeto, após a definição da comunicação utilizada, é desenvolver o circuito
microcontrolado que ficara acoplado ao protótipo. Onde este circuito será o
responsável em alimentar e comandar todas as suas funcionalidades. Basicamente
o circuito possui uma função especifica que é a de controlar os três motores de
propulsão do protótipo, onde segundo a Tabela 1, possuem as seguintes
especificações.
Tabela 1: Especificações dos motores do protótipo
MOTORES DO PROTÓTIPO
Motor Tensão (V) Amperagem (A)
Motor 1 12 2,5
Motor 2 12 2,5
Motor 3 12 2,5
A partir das características dos motores propulsores expostas na Tabela

acima, foi criada uma seqüência de objetivos propostos para o desenvolvimento do
controle, que são eles:
• Utilizar uma bateria externa de 12V e 50A para alimentação;
• Utilizar um cordão umbilical de 10 metros de comprimento para o envio da
alimentação e informações;
• Opções direcionais de controle para os motores de propulsão: esquerda,
ré, direita, frente, para cima e para baixo;
29
• Opção para controle de velocidade dos motores;
• Utilizar um microcontrolador para realizar o comando das opções de
controle;
Com as informações expostas acima, pode ser notado que serão utilizados
três motores, onde todos eles serão propulsores do protótipo. No total serão seis
comandos direcionais para seu controle, ou seja, para a execução de todos os
sentidos propostos, os motores deverão operar nos dois sentidos distintos utilizando
a inversão de giro. Partindo da idéia que o circuito controlador ficará constantemente
recebendo alimentação, a inversão de giro será realizada por uma ponte H na sua
saída para os motores, podendo habilitar e desabilitar o sentido desejado.
Outra observação pré-definida é o controle de velocidade dos motores. A
técnica utilizada para este controle chama-se Modulação por Largura de Pulso ou
simplesmente PWM (Pulse Wildth Modulation), que será descrita posteriormente
assim como o sistema da ponte H (VINICIUS, 1999).
Uma vez definido as técnicas de controle dos motores, estabelecemos o
microcontrolador que tenha tais funcionalidades, que neste caso será utilizado o PIC
16F877A, que possui 40 pinos no total, sendo eles 33 pinos somente como I/O, que
servirão como chaveadores dos componentes, e também 2 pinos similares a uma
saída analógica, podendo ser usados como moduladores de velocidade PWM
(MICROCHIP, 2000).
No item 3.1.2 foi citado o padrão serial de comunicação RS-232, esta é uma
das mais utilizadas para troca de informações com microncontroladores, pois o fato
de ser veloz e possuir apenas dois fios de dados, um apenas para o envio e outro
para o recebimento, facilita a projeção de um circuito controlador e posteriormente a
construção do cordão umbilical utilizado (TORRES, 2000). Por este motivo, a
comunicação serial já possui um componente específico para a eletrônica, sendo ele
o driver MAX232, que é o responsável pelo interfaceamento com o microcontrolador.
O PC enviará através de um fio de dados do cordão umbilical o comando
serial no padrão RS-232, o driver MAX232 converterá em um sinal compatível com o
microcontrolador, onde o restante do circuito por já estar recebendo alimentação
constante, apenas será chaveado a partir da execução do comando recebido caso
seja este um comando direcional, ou modulando o sinal analógico quando recebido
um comando de velocidade.
30
Pela sua fácil utilização e atendimento dos requisitos de comunicação e
controle deste projeto, todo o desenvolvimento do circuito controlador foi realizado
na versão 7.6 da ferramenta de simulação eletrônica Proteus Designer Suíte, da
indústria de softwares Labcenter Eletronics. O circuito completo se encontra
anexado no Apêndice A e a partir dele será detalhado a sua estrutura e
funcionamento nos subitens a seguir.
3.2.1. Regulador de Tensão
Um regulador de tensão possui uma função extremamente simples e que seu

próprio nome já o especifica, ele recebe uma determinada alimentação e o regula
para uma tensão desejada de acordo com a sua classe. No caso do regulador
utilizado neste circuito é o LM7805, que recebera uma tensão de 12V diretamente da
fonte de corrente alternada, e a regulará para 5V e aproximadamente 1A de corrente
em sua saída (MIRANDA, 2000).
É necessária à utilização de um regulador, pelo fato de todo o microcontrole
do circuito operar a uma tensão diferente dos motores, no caso 5V e 12V
respectivamente. Esta divisão de alimentação pode ser observada na Figura 14 a
seguir, onde aparecem duas trilhas de alimentação distintas provenientes do
conector da fonte externa, uma diretamente para os componentes que alimentam os
motores (Circuito integrado L298), e outra a partir do regulador, para seus
componentes de baixa tensão, no caso o driver MAX232 e o microcontrolador PIC
16F877A.
Figura 14: Regulador de tensão do circuito
Fonte: Do autor (RS1 - Câmera Robótica)
31
Convencionalmente um regulador de tensão possui apenas três pinos, o
receptor (Pino 1), emissor (Pino 3) e o GND (Ground, pino 2) como terra. Para o
desequilíbrio interno da carga elétrica foi utilizado dois capacitores em paralelo para
cada uma das alimentações existentes no circuito, para a tensão de 5V do
microcontrole um capacitor de 470uF e outro de 100nF (Robótica Simples, 2005).
Capacitância Total = C1 + C2 = (470 x 10-6)F + (100 x 10-9)F = 0,004701F

Q (Carga armazenada) = Ct * V = 0,004701F * 5V = 0,023505C
V (Tensão) = Q/Ct = 0,023505C / 0,004701F = 5V
E para manter uma corrente alternada estável na alimentação de 12V

destinada aos motores, são utilizados um capacitor de 1uF e outro de 0,1uF
(CARVALHOS, 2000).
Capacitância Total = C1 + C2 = (1 x 10-6)F + (0,1 x 10-6)F = 0,000011F

Q = Ct * V = 0,000011F * 12V = 0,000132C
V = Q/Ct = 0,000132C / 0,000011F = 12V
3.2.2. Driver MAX232 e Microncontrolador PIC 16F877A
O driver MAX232 é um transmissor/receptor duplo que inclui um gerador para

fornecer níveis entre -15V e +15V, a partir de uma tensão de 5V. Seus receptores
convertem as entradas seriais em níveis TTL (Transistor – Transistor Logic), e vice
versa (T.I.I., 2000). O TTL é o sinal aceito e compatível com o microcontrolador, ou
seja, a finalidade deste driver neste circuito é converter uma mensagem serial
enviada pelo computador externo, para ser interpretado pelo PIC 16F877A.
32
Figura 15: Funcionamento do Driver MAX232
Fonte: Do autor (ROGERCOM, Curso USB/Serial)
Analisando o conteúdo da Figura 15, pode ser observado que o driver possui
uma especificação pré-definida, que são seus geradores com um valor de 1uF cada
um deles (SOARES, 2008).
O microcontrolador PIC 16F877A é o componente principal de todo circuito
controlador deste projeto, pois é a partir dele que o restante deste circuito é
desenvolvido. A especificação deste microcontrolador estabelece seus pinos RA,
RB, RC, RD e RE, sendo os pinos I/O, totalizando 33 pinos, conforme apresentado
na Figura 16. Neste projeto todos os pinos I/O utilizados para controlar o protótipo,
serão configurados para operar apenas como saída (Output).
Um pino I/O funciona analogicamente, ou seja, trabalha em falso e verdadeiro
(0 e 1), onde o seu estado lógico 0 representa uma tensão de saída de 0V, e seu
estado lógico 1, uma tensão de 5V. Estas informações podem ser simplificadas
dizendo que, quando o pino se encontra no estado 0 ele esta desligado, e quando
estiver no estado 1 ele esta ligado (MICROCHIP, 2000).
33
Figura 16 Pinagem do microcontrolador PIC 16F877A
Para o controle direcional de todos os motores de propulsão, foi utilizado a

classe de pinos RD, que representam 8 pinos no total, embora apenas 6 deles foram
necessários para este comando. Todos eles funcionarão como chaveadores,
habilitando e desabilitando a Ponte H realizada pelos CI’s (Circuito Integrado) L298,
pois os mesmos já estarão sendo alimentados seguindo a teoria de um transistor
comum.
Os pinos 13 (CLKIN) e 14 (CLKOUT) são responsáveis por manipular o
oscilador de cristal. Este oscilador será o controlador do relógio (Clock) do
microncontrolador, e é a partir dele que será criada a sincronização com o relógio do
PC externo para o recebimento dos bits de dados, e também o calculo e
desenvolvimento do controle de velocidade dos motores através da modulação
PWM. Conforme as especificações do microcontrolador será utilizado um oscilador
de cristal com 4MHz de freqüência (Robótica Simples, 2008).
Pinos que representam os moduladores PWM são os de número 16 (CCP2) e
17 (CCP1), onde apenas um deles (CCP1) será utilizado para o controle de
velocidade dos motores, uma vez definido que todos estarão operando em uma
velocidade única, todos eles podem receber o sinal gerado do mesmo pino.
34
Figura 17: Figura do microcontrolador apto para receber mensagens de uma porta serial
Fonte: Do autor (ROGERCOM, Curso USB/Serial)
A Figura 17 acima mostra o conector emissor/receptor serial do PC, o driver

MAX232 e o microcontrolador, todos eles conectados e com seus componentes pré-
estabelecidos, como por exemplo, para o PIC 16F877A, os geradores capacitivos de
15pF, o oscilador de cristal (XTAL) com 4Mhz de freqüência, um resistor de 1K Ω
logo em seu pino de alimentação de número 1, e também os detalhes da pinagem
utilizada para o controle do restante de todo circuito (MICROCHIP, 2000).
3.2.3. Circuito Integrado L298
Os componentes responsáveis em alimentar os motores são os circuitos

integrados L298, eles podem trabalhar com tensões elevadas de até 46V e até 4A
de corrente, sendo projetado para aceitar comandos analógicos TTL, possibilitando
seu uso a partir de um microcontrolador. Normalmente é utilizado para comandar
35
cargas indutivas como reles, solenóides, motores DC e motores de passo (ST
Microelectronics, 1995) (SOUZA, 1998).
Este CI possui uma pinagem relativamente simples para sua utilização, sendo
dividos em duas classes (A e B), onde ambas possuem 2 pinos de entrada (input)
para receber os comando TTL do microcontrolador e 2 pinos de saída (output) para
direcionar a alimentação aos pólos dos motores. Isso significa que é possível
controlar até dois motores por um único chip. Mas pelo fato de não suportar uma
corrente adequada para controlar mais de um motor de propulsão do protótipo, será
utilizado neste projeto um CI para cada um deles, representando um total de 3 CI’s.
A sua estrutura possui um pino (Pino 6, VS ou Supply Voltage) que recebe
uma alimentação constante da fonte, neste caso 12V, e será exatamente esta há ser
enviada para os motores. Podemos considerar que o funcionamento deste CI segue
a teoria de um transistor, onde este pino teoricamente seria o seu coletor, os pinos
input a base e seu respectivo output o emissor. Outro pino a ser considerado é o
VSS (Logic Supply Voltage), que é representado pelo pino de número 9, onde ele
recebe o nível lógico de controle do CI, 5V provenientes do regulador tensão
(PAULA, 2000).
Cada classe de pinos possui um denominado Enable, que são os
responsáveis em habilitar ou desabilitar o uso desta classe. Este pino ficará
conectado diretamente no microcontrolador, recebendo o seu sinal lógico, portanto,
quando receber o sinal em nível alto, os pinos I/O da classe estão habilitados, e
quando este sinal estiver em nível baixo, à classe permanece desabilitada para uso
independentemente do nível que esta sendo recebido pelos seus respectivos pinos
input. Aproveitando-se deste fato utilizamos à modulação PWM exatamente no pino
Enable, modulando sua habilitação/desabilitação para controlar a velocidade de giro
dos motores (SOUZA, 1998) (PAULA, 2000) (RABELO, 2000).
36
Figura 18: Funcionamento do CI L298
Fonte: Do autor (ROBÔS AUTONOMOS)
A Figura 18 exemplifica toda a funcionalidade do CI L298 em comparação

com o que foi citado até então. Podemos observar o que o pino 9 recebendo o nível
de controle, pino 4 sendo alimentado pela fonte, pino 6 recebendo o sinal analógico
diretamente do pino CCP1 do microcontrolador para o seu controle PWM, seus
pinos input conectados as duas portas lógicas do microcontrolador (RD7 e RD6), e
seus pinos output enviando a alimentação para o motor, realizando a ponte H. Todos
os três CI’s trabalham de maneira perfeitamente igual.
3.2.4. Ponte H
A ponte H é o método utilizado para o controle direcional dos motores deste

projeto. Ela será utilizada a partir dos sinais analógicos gerados pelos pinos I/O do
microcontrolador para chavear o sentido de rotação dos motores, apenas invertendo
a polaridade de seus terminais.
Para utilizarmos uma ponte H basicamente precisamos de 4 chaves
mecânicas ou eletrônicas posicionadas formando a letra “H”, sendo que
teoricamente cada uma localiza-se num extremo em relação ao motor (PATSKO,
2000).
Os dois componentes superiores das pontes H da Figura 15 podem ser
representados por dois transistores, e os inferiores por dois diodos, formando o “H”.
37
Os transistores por já estarem sendo alimentados em seu coletor, apenas aguardam
o seu fechamento na base pelo comando positivo do microcontrolador. Os diodos
são responsáveis em drenar a corrente que poderia forçar a passagem através dos
transistores, pois quando os transistores são desligados, há a interrupção da
passagem de corrente pelo circuito, mas de acordo com as capacidades indutivas do
motor, ela força a corrente a continuar fluindo, o que pode danificar os transistores
(CARVALHOS, 2000).
Para chavear os motores, foi definida a regra de controle que servirá para
comandar sua direção de giro, esta regra será apresentada na Tabela 2.
Tabela 2: Controle analógico dos motores
Controle Analógico
Terminal 1 Terminal 2 Execução
0 0 Parado
1 0 Direção 1
0 1 Direção 2
1 1 Proibido
Quando o CI L298 recebe em seus pólos o segundo comando analógico,

conforme a Tabela 2, ele aciona o movimento do motor em um sentido, alimentando
o terminal 1 e utilizando o terminal 2 como terra, quando invertemos a chave
utilizando o terceiro comando da Tabela, o motor se movimenta no sentido contrario.
A Tabela define o quarto comando sendo uma execução proibida, pois isso se da ao
fato que o fluxo da corrente iria direto para o outro pólo positivo do motor, causando
um curto circuito que poderia danificar tanto o CI L298 quanto os motores.
Este exemplo de chaveamento de motores pode ser observado na Figura 19,
verificando a execução do segundo e terceiro comando de controle da Tabela 2, a
partir da idéia que quando fechamos um de seus pólos, seu diodo correspondente
libera o fluxo de corrente para o aterramento.
38
Figura 19: Execução do segundo e terceiro comando de controle da Tabela 2
Fonte: PATSKO 2006
Para o controle dos motores de propulsão, a ponte H será realizada pela

estrutura interna do CI L298, conforme apresentado na Figura 20 (ST
Microelectronics, 1995).
Figura 20: Estrutura interna do CI L298
Fonte: PATSKO 2006
Analisando a Figura acima, podemos observar que sua estrutura já é

composta por dois transistores para cada pino de saída, e que recebendo pelo pino
4 (VS) alimentação constante diretamente da fonte, apenas abrem caso seu input
correspondente for fechado pelo microcontrolador recebendo o sinal analógico alto,
39
ou permanecem fechados quando utilizados como terra, descarregando a corrente
em seu pino 8 (GND) e impossibilitando seu retorno para o circuito. Para completar o
funcionamento da ponte H na estrutura do circuito, foi adicionado um par de diodos
em série para cada pino output conectado aos pólos dos motores, podendo ser
observado na Figura 21 (CARVALHOS, 2000) (SOUZA, 1998).
Figura 21: Ponte H completa
Fonte: Do autor (Sistemas Baseados em Microprocessadores)
3.2.5. PWM
Modulação por largura de pulso ou simplesmente PWM, é uma técnica

aplicada para o controle de velocidade de motores de corrente continua ou
alternada. Com esta técnica podemos manter seu torque também em baixas
velocidades (PNCA, 2005).
Neste tipo de modulação controlamos o ciclo ativo do sinal analógico, em
outras palavras, modificamos a largura do pulso de acordo com a amplitude deste
sinal. Podemos considerar um ciclo ativo a porção do tempo em que o sinal
permanece em nível alto durante um determinado período de tempo, por exemplo,
um sinal com o período de 1s e 70% do ciclo ativo, permanece 0,7s em nível alto e
0,3s em nível baixo, este exemplo pode ser observado na Figura 22 (MALAQUIAS,
2002).
40
Figura 22: Exemplo de um ciclo ativo em um determinado período de tempo
Fonte: MALAQUIAS
Um sinal PWM pode ser considerado um sinal analógico, pois num instante
de tempo é “1” e em outro é “0”, onde 1 é o tempo durante o qual a carga é
alimentada, e 0 é o tempo durante o qual a carga não é alimentada (GUERREIRO,
2004).
Para demonstrar a utilização da modulação no controle de velocidade dos
motores deste projeto, exemplificaremos da seguinte forma. Os motores necessitam
para operar em pleno movimento de uma alimentação total de 12V, e a largura de
um pulso ocorre exatamente em 1s. Se configurarmos o ciclo do pulso que habilita
os motores em 80% em nível alto, a tensão média aplicada ao motor será 9,6V.
Caso configurado com um ciclo 30% ativo, a tensão média aplicada ao motor será
3,6V. Este exemplo está apresentado na Figura 23.
Figura 23: Exemplo de modulação para os motores propulsores
Fonte: Do autor (Modulador e demodulador PWM)

41
Conforme citado no subitem 3.2.2, calculamos a largura de um pulso a partir
da freqüência do oscilador de cristal utilizado para controlar o clock do
microcontrolador, onde esta formula está definida pela linguagem de programação
de seu sistema, que no caso deste projeto será a linguagem C especifica para
microcontroladores PIC. O calculo e funcionamento do controle de velocidade dos
motores propulsores via PWM, será detalhado no subitem 3.4, onde será descrito a
estrutura e toda funcionalidade do sistema desenvolvido para o microcontrolador.
3.3. Programa do computador externo
O sistema de controle da superfície será desenvolvido para ser utilizado a

partir de qualquer PC que possua uma porta I/O serial disponível para ser utilizada.
Este sistema controlador conterá uma interface visual que possibilitara o operador
carregar e visualizar as imagens captadas pela webcam acoplada ao ROV,
comandar a navegação direcional com o auxilio de opções que podem ser utilizadas
tanto com os eventos gerados pelo mouse, quanto utilizando teclas do teclado como
atalho de controle, assim como uma opção para controlar a velocidade dos motores.
A plataforma escolhida para seu desenvolvimento é a linguagem de
programação orientada a objeto (OO) Java 2EE (Enterprise Edition), criada pela Sun
Microsystems, e seu uso é disponibilizado gratuitamente. O IDE (Integrated
Development Environment) utilizado para a implementação desta linguagem foi o
JCreator da Xinox Software, que pode ser utilizado para trabalhar com diversos tipos
de linguagens, embora seja uma poderosa ferramenta utilizada para aplicações
Java (XINOX , 2004).
Foram utilizados conceitos de engenharia de software, mais especificamente
UML (Unified Modeling Language) ou Linguagem de Modelagem Unificada, para o
desenvolvimento da arquitetura do sistema. Esta linguagem auxilia a visualizar o
desenho e a comunicação entre objetos, possibilitando enxergar a estrutura do
trabalho em diagramas padronizados. O conceito UML utilizado para estruturar o
sistema foi o diagrama de classe, onde por este, pôde ser classificado e exposto
todos os objetos do sistema junto com suas interligações e compartilhamentos. Este
diagrama trabalha restritamente com a apresentação de objetos, o que facilita o
42
desenvolvimento do sistema, pois simula perfeitamente sua estrutura e
funcionamento, uma vez definido a utilização de uma linguagem orientada a objeto
para o controlador da superfície (MEDEIROS, 2007).
Pode ser observado no diagrama de classe anexado no Apêndice B, que o
sistema possui duas classes especificas desenvolvidas e utilizadas para o controle,
WebCam e Comm, onde elas respectivamente configuram e comandam o sistema
de reprodução de imagens e a conexão com a porta serial utilizada para enviar os
comandos para o microcontrolador. Para a utilização da classe WebCam é
necessário utilizar uma API (Application Programming Interface) da linguagem Java
especifica para o desenvolvimento de controle multimídia, que é a JMF (Java Media
Framework). Igualmente utilizamos a API Comm para possibilitar o manuseio das
funcionalidades das portas I/O.
Uma API é um conjunto de rotinas e padrões estabelecidos para a utilização
de suas funcionalidades por softwares desenvolvidos para apenas manusear seus
serviços, ou seja, uma API é acessível apenas por programação para utilizar
características especificas menos evidentes a um sistema comum (MEDEIROS,
2007). Como, por exemplo, as API’s utilizadas neste projeto, pois cada uma é criada
especificamente para um determinado tipo de desenvolvimento, comunicação I/O e
imagens.
Outra opção disponível desenvolvida é a interface visual de configuração
onde podemos definir os parâmetros dos comandos de controle do ROV, e as teclas
de atalho para utilizar o teclado como controlador, todas essas opções sendo salvas
em arquivos, não necessitando sua configuração novamente sempre que aberto o
programa.
Nos próximos subitens deste capitulo será descrita a estrutura e as principais
funções do sistema de controle desenvolvido para o computador da superfície, onde
o mesmo estará completo anexado no Apêndice C, onde poderá ser observado
constantemente ao decorrer das explicações das classes desenvolvidas.
43
3.3.1. API Comm
A API Comm pode ser utilizada para o envio e recepção de dados entre dois
periféricos, pois em seu controle entre as portas podemos configurar interrupções,
sincronizar clock, reconhecer stop bits, paridade e ainda lidar com o código ASCII
(American Standard Code for Information Interchange) gerado pelo teclado. Com o
padrão atual de microprocessadores e microcontroladores, pode ser utilizado
recursos como esta API para fazer este trabalho de comunicação (ORENSTEIN,
2007).
Para integrar a API Comm á maquina virtual Java do computador e
disponibilizar sua utilização, é necessário realizar primeiramente três passos após a
descompactação do arquivo disponibilizado no link
http://java.sun.com/products/javacomm/index.jsp da Sun Microsystems
(GOMES, 2005). Estes passos são:
• Copiar o arquivo “win32com.dll” para a pasta BIN do diretório JDK (Java

Development Kit);
• Copiar o arquivo “comm.jar” para a pasta \BIN\LIB\EXT do diretório JRE
(Java Runtime Environment) e JDK;
• Copiar o arquivo “javax.comm.properties” para o diretório \BIN\LIB do
diretório JDK
A classe Comm do sistema será a responsável em realizar todo o controle da

comunicação serial, carregando as portas disponíveis, conectando com a porta
escolhida, enviando comandos e fechando a conexão se assim desejado. Para
importarmos as funcionalidades da API Comm e possibilitar sua utilização, após sua
integração com a maquina virtual do computador, basta carregar o pacote com o
comando “import javax.comm.*;” no declaração dos pacotes utilizados no inicio da
classe.
O método getPortasIO(), é o responsável em carregar e retornar em um vetor
as portas I/O do computador. Este método é invocado pela classe LoadingInterface,
que é a responsável em carregar todos os parâmetros de controle, como as portas
I/O e os dados de controle, que são os comandos de envio para o microcontrolador
44
e as teclas de atalho do teclado. Todos estes parâmetros são carregados para as
variáveis da classe e enviadas para o menu visual principal na inicialização do
programa, que é a classe MenuInterface. Este método pode ser observado na Figura
24.
Figura 24: Método getPortasIO()
Fonte: Do autor (Comunicação Serial Utilizando a API da SUN)
Outro método é o getConexao(), que verifica se a porta escolhida realmente é

uma porta serial e retorna um valor booleano verdadeiro caso ocorra a conexão sem
nenhum problema com a porta I/O escolhida, ou falso se ocorrer algo durante o
processo de conexão, sua codificação pode ser observada na Figura 25.
Figura 25: Método getConexao()
Fonte: Do autor (Java 2: Ensino Didático: Desenvolvendo e Implementando

Aplicações)
Na Figura 19 pode ser observado que a linha “if(getConexaoCom(Porta) ==

true)”, invoca o método GetConexaoCom() enviando a variável do tipo String que
contem a porta escolhida para uso. Durante a execução serão realizados os
procedimentos para a conexão com a porta, e retornará verdadeiro caso tenha sido
45
realizada sem ter encontrado nenhuma exceção. O método getConexaoCom() será
apresentado na Figura 26.
Figura 26: Método getConexaoCom()
Durante a execução do método getConexaoCom() há uma linha fundamental

para a configuração do sistema de controle emissor, que é a
“portSerial.setSerialPortParams(19200,portSerial.DATABITS_8,portSerial.STOP
BITS_1, portSerial.PARITY_NONE);”, onde nela está definido o tipo de
comunicação que será estabelecida com o sistema do microcontrolador. Nesta linha
definimos quais são as taxas de baud (19.200), a quantidade de bits do comando
enviado (8 bits), a quantidade de stop bits (1 bit), e a existência de um bit de
paridade, neste caso configurado como NONE, que significa que não será utilizado
(GOMES, 2005). Todos os parâmetros existentes nesta linha de controle foram
detalhados no subitem 3.1, onde está descrito o funcionamento da comunicação
serial, e uma vez definido que será utilizado o tipo de comunicação assíncrono, a
configuração do sistema do microcontrolador terá de estar perfeitamente compatível
e sincronizada com esta do sistema do computador externo. A configuração do
46
sistema do microcontrolador está descrito no subitem 3.4, onde será exposto sua
estrutura e funcionamento.
Na seqüência do código aparecem os comandos catch que representam os
erros que podem ocorrer ao decorrer da execução das linhas de configuração da
comunicação (FURGERI, 2005). A seguir na Figura 27 poderá ser observado o
método encarregado de enviar os comandos seriais para o microcontrolador, este é
o setExecutaComando().
Figura 27: Método setExecutaComando()

O ultimo método desenvolvido da classe Comm é o setClose(), que

simplesmente encerra toda a configuração e a conexão com a porta serial, caso
esteja esta conectada.
3.3.2. API JMF
A API JMF pode ser utilizada para fins que envolva vários tipos de formatos de
media de um computador, como capturar fotos e vídeos com uma webcam,
reproduzir musicas ou até mesmo gravar sons por um microfone. Para sua
integração com a maquina virtual Java instalada no computador, esta API
igualmente a API Comm também necessita de alguns passos para ser integrada e
disponibilizada para sua utilização. Basta descompactar o arquivo disponibilizado no
link http://www.oracle.com/technetwork/java/javase/download-142937.html (JMF, 2006). Os
passos são:
47
• Instalar o software JMF 2.1.1e;
• Copiar o arquivo “jmf.jar” na pasta /BIN/LIB/EXT do diretório JRE e JDK;
Não foi comentado no capítulo do circuito controlar sobre a forma de

transmissão de dados da webcam, pois será utilizado no cordão umbilical um cabo
USB padrão exclusivamente para câmera, não sendo conectado ao circuito, mas sim
diretamente à mesma. E é por meio deste cabo que a câmera recebe a sua devida
alimentação e envia as imagens para a interface visual do programa do computador
da superfície.
A seguir será demonstrado os métodos da classe WebCam, que é a
responsável em controlar todas as funcionalidades disponibilizadas pela API JMF
utilizada para o controle das imagens geradas. O método getComponentWebCam()
é utilizado para carregar o driver da WebCam USB conectada ao computador, iniciar
a captura, e atribuir as imagens ao item “Component” especifico para esta utilização
de media, este item é o responsável em reproduzir as imagens capturadas pela
câmera na interface visual do programa. O método será apresentado na Figura 28
(Javafree.org, 2006).
Figura 28: Método getComponentWebCam()
Fonte: Do autor (Java Media Framework basics)
48
As palavras entre aspas ("vfw:Logitech USB Video Camera:0") da linha de
código CaptureDeviceInfo deviceInfo =
CaptureDeviceManager.getDevice("vfw:Logitech USB Video Camera:0"); da
Figura 22, é onde especificamos exatamente qual a WebCam que será carregada,
neste caso, uma câmera padrão conectada por meio de uma porta USB (VINICIUS,
1999). Este é um método booleano, ou seja, se ao decorrer da execução das linhas
de código para capturar o driver da webcam instalada no computador, e atribuí-la ao
gerador de imagens (Component) apresentarem algum erro, o método ira retorna o
valor falso para aquele que a executou, e apenas ira retornar verdadeiro se não
ocorrer nenhum erro na sua execução.
O método que retorna o Component que irá gerar as imagens no menu
principal do programa é o getComponent(), ele possui a função simples de apenas
retornar o gerador de imagens para ser apresentada na interface visual, caso a
conexão com o driver da câmera esteja estabelecido (FURGERI, 2005). O
responsável em finalizar a captura das imagens, desconectar-se do driver carregado
e limpar suas variáveis é o método setClosePlayer() (Javafree.org, 2006).
3.3.3. Interface de Configuração dos Parâmetros de Controle
A interface visual de configurações dos parâmetros de controle disponibiliza

uma dinâmica nos dados escolhidos para serem os controladores do protótipo,
sendo eles os comandos de envio para o microcontrolador, e as teclas do teclado
que servirão como atalho para o envio destes comandos escolhidos. Para abrir esta
janela está disponível no menu visual principal do programa duas opções, uma na
barra de menus selecionando a opção “Arquivo”, em seguida seu item “Controle”, ou
pela opção de um botão posicionado logo abaixo das portas I/O.
Quando selecionado uma dessas duas opções será apresentada à tela de
configurações, já sendo carregados os dados salvos nas suas respectivas caixas de
texto, caso não esteja cadastrado nenhum tipo de parâmetro serão carregadas todas
as caixas de texto com o número zero em seu interior. A classe responsável em
controlar esta interface de parâmetros é a ControleInterface, e sua interface visual
será apresentada na Figura 23.
49
Figura 29: Interface de configuração dos parâmetros de controle
Fonte: Do autor (Java 2: Ensino Didático: Desenvolvendo e Implementando Aplicações)
Pode ser observado na Figura 29 que a interface de controle possui três

colunas, com os nomes Comandos, Valor e Teclado respectivamente. A coluna
“Comandos” especifica quais os comandos existentes para serem configurados, na
coluna “Valor” é onde configuramos os comandos de envio para o microcontrolador,
sendo estabelecidos neste projeto para serem exclusivamente valores numéricos
inteiros, e por fim a coluna “Teclado” disponibiliza as opções de escolha das teclas
do teclado que serão utilizadas como atalho. Ainda com base na Figura 29, os
números inteiros da coluna “Teclado” são os códigos gerados pelas teclas
pressionadas nas suas caixas de texto, pois a linguagem Java atribui um valor
numérico para identificar cada uma das teclas existentes no teclado (FURGERI,
2005).
Para gerarmos os códigos das teclas é preciso programar no cabeçalho da
classe o controle de eventos KeyListener, pois é a partir desta implementação que
possibilitamos o seu método específico keyPressed (Tecla pressionada) gerar na
caixa de texto o código numérico da tecla pressionada. Este método é utilizado para
o controle de eventos, ou seja, ela sempre é chamada quando for pressionada
qualquer tecla no interior das caixas de texto desta coluna, verificando qual é a caixa
de texto sendo utilizada e retornando na mesma o seu código, a partir das linhas
internas do método que contem o comando e.getKeyCode(), e desabilita o retorno
50
do valor alfanumérico da tecla pelo código e.setKeyCode(e.VK_ESCAPE); que esta
no final deste mesmo método (FURGERI, 2005).
A classe que salva e retorna os dados salvos anteriormente que são
apresentados na interface de configuração é a ArqDat. Embora ela controle os
arquivos com as opções salvas ela não é utilizada pela classe ControleInterface para
retornar os parâmetros de controle. Os parâmetros são enviados automaticamente
para a classe ControleInterface quando selecionado uma das duas opções descritas
acima para abrir a interface visual de controle, esses dados são enviados como um
JavaBean, que é um componente de software designado para receber, armazenar e
retornar dados, além de poder ser reutilizado e vinculado a qualquer aplicação. Por
exemplo, um JavaBean é uma classe que funciona como um banco de dados
dinâmico virtual, onde a partir de uma segunda classe é possível atribuir diversos
tipos e uma quantidade infinita de valores a ela, e posso recuperar estes mesmos
valores utilizando uma terceira classe que receba este JavaBean como argumento
(NETO, 2008).
O JavaBean criado recebe o nome de ControleBean, ele irá retornar os três
parâmetros de controle manipulados neste projeto, que são eles os comandos de
envio para o microcontrolador e as teclas de atalho do teclado, ambos sendo
enviados numa array do tipo numérico inteiro. Uma array é utilizada para armazenar
um conjunto de itens que tenham o mesmo dado primitivo, ou seja, possibilita
armazenar uma grande quantidade de valores em uma única variável,
diferentemente do vetor, pois apesar de também ser utilizada para armazenar
infinitos valores, pode armazenar qualquer tipo de dados (FURGERI, 2005).
O ultimo parâmetro da classe ControleBean é um vetor contendo as portas
I/O encontradas a partir do método getPortasIO() comentado no subitem 3.3.1, mas
este vetor não será utilizado pela classe de configurações. O JavaBean
ControleBean completo pode ser observado no Apêndice C, onde o programa
controlador da superfície esta anexado.
O método da classe ControleInterface que recebe o ControleBean contendo
as informações de controle, é o setParametrosBean() que será apresentado na
Figura 30.
51
Figura 30: Método setParametrosBean()
Logo após o método setParametrosBean() receber as informações e a janela

de controle ser aberta, o método setCarregaComandos() é executado para carregar
nas caixas de texto os seus respectivos comandos e códigos das teclas do teclado.
Após definidas às configurações por parte do operador do sistema, temos a
opção de salvar às mesmas a partir do botão “Salvar”. Quando pressionado o botão,
o evento responsável pelo seu controle é acionado, que é o método chamado
actionPerformed. Primeiramente o método actionPerformed executa outro método
chamado setVerificaComandos(), que tem a função de verificar as caixas de texto da
interface de controle, comparando todas as caixas da mesma coluna entre si, para
certificar de que não existe nenhum código repetido entre eles, ou algum caractere
que não seja um valor numérico. Esta verificação se torna necessária, pois a
existência de valores errôneos poderia ocasionar incompatibilidades ao tentar
controlar o ROV subaquatico, como por exemplo, uma confusão na interpretação do
microcontrolador a partir de um envio indevido de um comando repetido pelo
programa emissor. Este é um método booleano, por isso ele irá retornar verdadeiro
caso não encontre qualquer erro como, caracteres alfanuméricos, caixas de texto
em branco ou valores repetidos, e caso seja encontrado qualquer erro o método ira
retornar falso e interrompera o processo de gravação dos dados.
Ao termino da execução do método setVerificaComandos(), será atribuída a
uma variável booleana um valor verdadeiro ou falso. Esta variável será analisada e
apenas caso seja reconhecida como verdadeira, será executada a seqüência do
processo de gravação dos valores. Nesta seqüência será executado o método
setSaveDat(), que diferentemente do processo inicial onde carregamos os dados de
controle na interface visual como descrito acima, utilizamos a classe ArqDat para
salvar as informações nos arquivos de dados. O método setSaveDat(), executa o
método setDat() da classe ArqDat atribuindo como argumentos duas array com os
52
valores inteiros de controle, o processo de gravação nos arquivo pelo método
setDat() será descrito no subitem 3.3.4.
Por ultimo, o método actionPerformed irá salvar nos parâmetros do JavaBean
ControleBean as informações configuradas ou atualizadas para serem utilizadas
como controle do ROV. E este JavaBean contendo as informações de controle será
atribuído novamente a classe MenuInterface pelo método setParametrosBean().
Todo o método actionPerformed responsável em executar o processo de gravação
das informações será apresentada na Figura 31.
Figura 31: Método actionPerformed()
3.3.4. Classe ArqDat
A classe ArqDat é a responsável em utilizar os arquivos com os dados de

controle do protótipo. O tipo de arquivo utilizado para salvar as informações será no
formato dat, que é um formato universal e pode ser lido por qualquer tipo de
programa que suporte os tipos de dados salvos no conteúdo do arquivo, ou seja,
normalmente é utilizado por sistemas para armazenar dados, parâmetros,
53
informações, configurações que serão utilizados no decorrer de sua execução (
TERRA, 2008).
Para habilitarmos a manipulação de arquivos basta importarmos no cabeçalho
o pacote I/O, este pacote habilita a classe a utilizar todas as funcionalidades de
entrada e saída de dados, para arquivos com qualquer tipo de formato.
O primeiro dos três métodos que a classe possui é o setDat(), e é por meio
deste que será salvo os comandos de envio, e os códigos das teclas de atalho em
dois arquivos distintos na pasta de configurações do diretório do programa, com os
nomes Comandos e ComandosTeclado respectivamente, ambos com o formato dat.
O método recebe como argumentos duas array do tipo inteira contendo as
informações que serão salvas nos arquivos.
O método que retorna uma array com os comandos de envio do arquivo
Controle.dat, é o getDatComandos(), ele simplesmente abre este arquivo que está
na pasta de configurações e realiza a varredura dos dados capturando cada um
deles para os campos desta array numérica inteira. Caso anteriormente não tenha
sido realizado nenhum processo de gravação e o arquivo não exista, a array será
retornada com os valores zerados. Todo o processo do método
getDatComandosTeclado() de abrir e retornar os valores é exatamente igual ao
método getDatComandos(), com a única diferença que irá utilizar o arquivo
ComandosTeclado.dat que contem os códigos das teclas de atalho.
3.3.5. Interface Visual Principal
A interface visual desenvolvida para interagir com o operador do ROV será o

menu principal de controle, onde nela estará importadas e conectadas todas as
classes descritas anteriormente, prontas para serem executadas.
A classe que inicia a execução de todo o programa é a MainInterface, ela tem
uma única função, que é a de executar o método construtor da classe
LoadingInterface, onde nesta serão carregados para o JavaBean ControleBean os
três parâmetros de controle comentados nos subitens anteriores, que são eles as
portas I/O, os comandos de envio e os códigos das teclas de atalho. As portas I/O
disponíveis no computador serão encontradas e capturadas a partir do método
getPortasIO() da classe Comm descrita no subitem 3.3.1. Os comandos de envio e
54
os códigos das teclas de atalho serão carregados pelos métodos getDatComandos()
e getDatComandosTeclado() respectivamente, ambos da classe ArqDat explicada
no subitem 3.3.4 deste capitulo.
Após todos os parâmetros de controle estarem carregados no JavaBean
ControleBean, a classe LoadingInterface enviará este JavaBean para a classe visual
MenuInterface, onde a partir de então o menu principal será carregado na tela do
computador, já com todos os parâmetros carregados e disponíveis em seus devidos
campos. Com a execução da classe LoadingInterface enviando os parâmetros para
a classe visual MenuInterface, a interface visual irá ser apresentada, e esta pode ser
observada na Figura 32.
Figura 32: Interface Visual
Fonte: Do autor
Com a interface visual completa apresentada na Figura 26, podemos observar

o que foi comentado até então, que são, por exemplo, o campo destinado a gerar as
imagens da webcam acoplada ao ROV, as opções para visualizar a interface com as
55
configurações de controle descrita no subitem 3.3.3, os botões de envio dos
comandos direcionais, o controlador de velocidade (Slider) e a caixa de combinação
(ComboBox) com as portas I/O já disponíveis para escolha. Todas elas com imagens
para ilustrar a interface. Para utilizar alguma das portas I/O para enviar os comandos
de controle, primeiramente devemos criar uma conexão com a porta, através do
botão “Conexão” disponível ao lado direito da caixa de combinação das portas I/O,
este botão irá executar o método getConexao() da classe Comm explicada no
subitem 3.3.1, podendo ser observada na Figura 19, enviando como argumento a
porta serial escolhida para utilização.
Somente após a conexão com a porta serial ser realizada perfeitamente será
liberado a utilização dos botões de controle. Cada um desses botões quando
pressionado irá executar o método getExecutaComando() da classe Comm,
enviando como argumento o seu devido comando.
Igualmente a conexão com a porta serial, também é preciso criar outra
conexão com a webcam acoplada ao protótipo, para isto o botão “WebCam” logo
abaixo do componente destino a gerar suas imagens, executara o método
getComponentWebCam() da classe WebCam descrita anteriormente. E caso não
haja nenhum erro nesta execução, as imagens serão direcionadas para o
componente de visualização da interface visual. Para finalizar as conexões com a
porta serial e a webcam, basta clicar novamente nos seus respectivos botões.
3.4. Programa do Microcontrolador
O programa receptor é aquele que ficará gravado na memória do

microcontrolador PIC 16F877A da placa de circuito impresso desenvolvida, ele foi
criado utilizando a linguagem C para microcontroladores, que é específica para este
tipo de componentes eletrônicos. Este sistema possui a finalidade de receber os
comandos do computador da superfície, podendo ser de controle de velocidade ou
direcional.
No inicio da codificação é necessário definir alguns parâmetros que serão
utilizados como configurações para a execução do programa. Estas linhas serão
apresentadas na Figura 33 (PEREIRA, 2001).
56
Figura 33: Linhas de configurações do sistema do microcontrolador
Fonte: Do autor (Microcontrolador PIC Programação em C)
Na primeira linha, o cabeçalho “#include <16F877A.h>” importa o pacote com

os dados que possibilitarão utilizar um microcontrolador com esta numeração, neste
pacote contem as constantes e definições do PIC 16F877A, como por exemplo, seus
fusíveis, pinos, comunicação suportada e seu relógio. Este relógio deve ser definido
a partir do valor do oscilador de cristal que esta conectada aos pinos destinados a
realizar a esta leitura (ROGERCOM, 2006).
O valor do oscilador de cristal utilizado pelo microcontrolador é de 4MHz ou
4000000Hz. Ainda pode ser observado na Figura 27 que a linha “#use
delay(clock=4000000)” é a codificação que define a operação deste relógio, e é a
partir desta definição que sincronizamos a comunicação e podemos utilizar à
modulação PWM para o controle de velocidade (ROGERCOM, 2006).
Em sequência, a linha “#fuses
HS,PUT,NOWDT,NOBROWNOUT,NOLVP,NOPROTECT” define quais e como os
fusíveis internos do microcontrolador serão configurados. O significado desta
configuração esta apresentada na Tabela 3.
Tabela 3: Configuração dos fusíveis do microcontrolador
CONFIGURAÇÃO DOS FUSÍVEIS

Comando Descrição
HS (High Speed) Alta velocidade de processamento
PUT (Power Up Timer) Temporizador de power up ligado
NOWDT (No Watch Dog Timer) Desabilita o reset do programa caso trave
NOBROWNOUT Reset por queda de tensão desabilitada
NOLVP Programação e baixa tensão desabilitada
NOPROTECT Desabilita a proteção do código contra leitura
A ultima linha de comando da Figura 27 é a “#use rs232(BAUD=19200,

parity=N,BITS=8,rcv=PIN_C7)”, e por meio dela que definimos qual será a forma de
comunicação utilizada para receber as informações, no caso, RS-232. Também
pode ser observado nesta linha que ela contem tudo o que foi descrito sobre a
comunicação até então, que são, a taxa de baud utilizada (19200), os bits de
57
paridade (Nenhum), a quantidade de bits que compõe cada mensagem recebida (8
bits) e qual é o pino do microcontrolador que receberá estas informações (Pino RC7)
(ROGERCOM, 2006) (PEREIRA, 2001).
Foi comentado no subitem 3.1, onde foi descrito todas as características da
comunicação serial, que o tipo de transmissão de dados é o tipo assíncrono, e que
deveria ser previamente definido e configurado. Esta configuração será criada e
estabelecida a partir da declaração desta linha de código do receptor e a linha
(portSerial.setSerialPortParams(19200,portSerial.DATABITS_8,portSerial.STOP
BITS_1, portSerial.PARITY_NONE);) do método getConexaoCom() da classe
Comm descrita no subitem 3.3.1. O único parâmetro não configurado no código do
microcontrolador é o stop bits, pois este não se da necessária pelo fato de todo
comando serial recebido ou enviado possuir um bit padrão de parada para indicar o
seu termino (GOMES, 2005) (PEREIRA, 2001).
A codificação de recebimento das mensagens do computador externo será
apresentada na Figura 34.
58
Figura 34: Loop Eterno
Fonte: Do autor (. Microcontrolador PIC Programação em C)
3.4.1. Controle Direcional
Pode ser observado na Figura 28, que o programa estará executando um loop
eterno, ou seja, ele estará interminavelmente verificando se houve um comando
serial recebido pelo microcontrolador através do fio de dados do cordão umbilical.
Esta verificação é realizada pelo comando “if(kbhit())”, onde caso esta condição seja
considerada verdadeira, dara prosseguimento na execução dos códigos internos.
Comparando a Figura acima com a Figura 31 do subitem 3.3.3, pode ser observado
que as condições (case) dos comandos recebidos devem estar perfeitamente
relacionadas ao conteúdo dos parâmetros de envio, e somente com este
59
sincronismo que a execução do controle será realizada com sucesso (PEREIRA,
2001).
O código que executa o comando recebido caso seja este direcional, é o
“output_d(0bXXXXXXXX)”, sendo cada uma das variáveis “X” o valor 0 ou 1, que
indica respectivamente que o pino entrará em estado low or high (Baixo ou alto).
Cada uma das variáveis “X” representa os pinos I/O da classe RD, e define o estado
dos pinos RD7 ao RD0 ordenadamente, conforme apresentado na Figura 35
(PEREIRA, 2001).
Figura 35: Pinagem dos controles direcionais dos motores
Fonte: Do autor
Comparando o direcionamento da pinagem da Figura 35, com a execução de

cada comando direcional de acordo com a Figura 36 que utiliza os fundamentos
propostos na Tabela 2 do subitem 3.2.4, pode ser observado que a forma escolhida
e utilizada para executar os comandos direcionais para esquerda e direita, é
desligando um motor e utilizando o outro extremo, por exemplo, para o protótipo
virar para a esquerda, é desligado o motor da esquerda e habilitado somente o
motor da direita para realizar a execução. Para virar para a direita é realizado o
inverso do processo da esquerda, ou seja, o protótipo se movimenta para essas
duas direções não estando em movimento.
60
3.4.2. Controle de Velocidade
Para a utilização de PWM para o controle de velocidade dos motores,

primeiramente devemos utilizar um comando que o resultado deste mesmo será o
tempo do ciclo ativo expresso em ms conforme o relógio do microcontrolador. Este
comando é o “setup_timer_2(T2_DIV_BY_4, 255,1);”, onde “T2_DIV_BY_4”
representa especificamente que o tempo de instrução é 4 dividido por 4000000
(Valor do oscilador de cristal) multiplicado por 4, “255” representa o período, que
pode variar de 0 a 255, e o numero “1”, significa que esta formula de temporização
será utilizada para o fim de PWM (Robótica Simples, 2005) (CARVALHOS, 2000). O
valor resultante deste comando será:
Tempo de Ciclo = (4/4000000) x 4 x 255 = 0,00102s = 1,02ms (1,02KHz)
Para definirmos o ciclo ativo do pino (RC2) responsável em modular o sinal

analógico alto, e que estará diretamente conectado aos pinos enable dos CI’s L298,
é utilizado o comando “set_pwm1_duty(duty);” onde o valor de duty (ciclo) entre
parênteses, pode variar de 0 á 1020, que é a freqüência de saída resultante do
calculo acima do tempo de ciclo. Sendo a velocidade maior quando o valor de duty
for elevado, pelo fato do tempo do ciclo ativo do pulso ser maior, e diminuindo a
velocidade quando o valor de duty for menor, pois elevamos o tempo do ciclo baixo,
desabilitando gradativamente seu funcionamento. Para habilitarmos a utilização
deste pino apenas devemos inserir após o calculo, o comando
“setup_ccp1(CCP_PWM)” (PEREIRA, 2001) (Mecatronica.org, 1998).
Quando recebido uma mensagem de aumento ou diminuição de velocidade
pelo computador externo, o programa executara a função “velocidade()”, atribuindo
como argumento o numero 1 para aumentar, e 0 para diminuir. Esta função foi
definida para executar apenas cinco níveis de velocidade, com isso os motores terão
a opção de operar a 0%, 25%, 50%, 75% e 100% de sua capacidade de trabalho.
Ou seja, por exemplo, quando o microcontrolador receber a mensagem para diminuir
a velocidade, será subtraído do valor da variável duty 25% do total (1020),
diminuindo o ciclo ativo e, portanto sua velocidade. O processo inverso é realizado
para o aumento da velocidade, somando á variável duty 25% do valor total a cada
61
mensagem de aumento, até atingir 100% de ciclo ativo, onde executara a velocidade
máxima.
O programa completo desenvolvido para o microcontrolador está anexado no
Apêndice D.
62
4. TESTES
Um problema muito grande no consumo de energia é no momento de

inversão dos motores, pois a força para inverter o sentido tem que ser maior, tendo
em vista que a roda estava girando para o sentido contrario.
A ferramenta de desenvolvimento e simulação Proteus utilizada para o projeto
do circuito controlador do ROV, também possui a alternativa de executá-lo
virtualmente, o que possibilita visualizá-lo em funcionamento, e com isso, o
tratamento de possíveis erros em sua arquitetura.
Para conectarmos o programa desenvolvido para o computador emissor ao
circuito do Proteus é necessário primeiramente criar um cabo serial virtual, onde ele
disponibilizara um interfaceamento entre ambos, simulando perfeitamente uma
possível troca de mensagens entre dois periféricos conectados um ao outro que
estejam programados ou configurados para uma comunicação serial. O programa
utilizado foi o VPSE (Virtual Serial Port Emulator) da empresa Eterlogic, craindo um
par (Pair) em suas opções, como por exemplo, uma suposta porta virtual COM2 e no
outro extremo do cabo a COM3, realizando o modo de comunicação full-duplex
(JEREK, 1998).
Para a utilização de umas das portas seriais virtuais pelo Proteus e
simularmos sua execução, é necessário primeiramente alterar o circuito adicionando
um componente chamado COMPIM, utilizado especificamente para este tipo de
simulação. Este componente segue as especificações de pinagem de uma porta
serial padrão, mas possui o detalhe que para enviar e receber mensagens, deve ser
invertido os cabos conectados ao microcontrolador, conectando seu pino TD ao pino
emissor do microcontrolador (25, TX), e seu pino RD ao pino receptor (26, RX). Após
o COMPIM estar conectado corretamente, o configuramos de acordo com o
proposto ao decorrer das explicações do sistema de comunicação deste projeto,
como a quantidade de bits de dados, stop bits, paridade e a taxa de baud, onde a
mesma será apresentada na Figura 36 (JEREK, 1998).
63
Figura 36: Configuração da comunicação serial do componente COMPIM
Fonte: Do autor (Como Conectar O Proteus A Uma Porta De Comunicação)
Na outra ponta do cabo serial virtual criado (COM3), é realizada a conexão

com o programa executado no computador, simplesmente a definindo quando
apresentada na combobox da interface visual e selecionando o botão “Conectar” que
inicia todo o processo de conexão e configuração da porta serial, conforme descrito
no subitem 3.3.
Figura 37: Porta serial virtual encontrada pela interface visual do computador externo
Fonte: Do autor
64
Para uma simulação visualmente mais próxima do real, foram substituídos
nas pontes H dos CI’s L298 com os diodos os pinos conectores que teoricamente
iriam ser plugados aos pólos dos motores, por um motor virtual DC simples
disponibilizado pelo Proteus nas opções de componentes simuladores
eletromecânicos. Este motor é acionado de acordo com a execução do circuito a
partir do recebimento do comando serial direcional do computador externo (BREIJO,
1995). Para a observação do PWM gerado para o controle de velocidade dos
motores também foi adicionado ao circuito um osciloscópio virtual que demonstra
perfeitamente as ondas do sinal analógico do pino CCP1/RC2 conectado as portas
enables dos CI’s L298 (KITOEAG, 2000). Por fim, para que o microcontrolador do
Proteus receba e execute os comandos recebidos basta adicionarmos em sua opção
“Program File” o caminho onde o programa desenvolvido para ser gravado na
memória do microcontrolador se encontra no computador.
Após a simples modificação do circuito e a conexão do cabo serial virtual
estar configurada em ambos os programas, podemos executar o Proteus
selecionando a opção “Play” de seu menu (BREIJO, 1995). A partir desta opção é
possível observar a troca de informações entre ambos os programas, a execução
dos mesmos pelo microcontrolador movimentando os motores virtuais em ambos os
sentidos, e também o sinal PWM demonstrado no osciloscópio. Algumas imagens
desta simulação e também da captação de vídeo do programa por meio de uma
webcam comum conectada ao computador, poderão ser observadas no Apêndice E
onde serão adicionadas imagens dos testes realizados.
65
5. CONCLUSÂO
As simulações citadas no capitulo 4 possibilitaram um teste geral do sistema

de controle projetado para o protótipo, que são eles, o programa do computador
externo e também o circuito em funcionamento executando nos motores
eletromecânicos as mensagens de controle recebidas pelo programa do
microcontrolador. Durante o processo de testes foi observado que a versão 7.6 do
Proteus utilizada para projetar o circuito não dava suporte para simulações PWM
(Robótica Simples, 2008), por isso apenas foi possível observar os motores em
funcionamento total, sem o controle de velocidade. Para contornar este problema foi
utilizada a versão 7.2 do programa apenas para simular o PWM do pino CCP1/RC2
que conforme citado durante o subitem 3.2 seria conectado aos pinos enables dos
CI’s L298 para realizar o controle de velocidade dos motores, e por meio desta outra
versão os testes puderam ser realizados com precisão no osciloscópio virtual. Este
teste somente no pino gerador de PWM realizada na versão anterior citada se deu
necessário, pois a falta de tempo impossibilitou redesenhar o circuito completo na
mesma.
Durante o processo de testes do protótipo em movimento na água alguns
problemas para alinhá-lo e equilibra-lo corretamente impossibilitou que a webcam e
o circuito controlador fossem acoplados em sua estrutura, o que ocasionou uma
remodelagem no sistema de controle, como a retirada da câmera do projeto e
utilizando o circuito na própria superfície direcionando por meio do cordão umbilical
apenas a alimentação dos três motores por meio de seis fios, e não enviando os
comandos para serem interpretados pelo microcontrolador e o próprio distribuir
internamente a alimentação conforme citado nos objetivos iniciais.
Com o protótipo remodelado e em funcionamento foi constatado que os
motores possuem uma capacidade de trabalho abaixo do esperado,
desempenhando uma velocidade moderada mesmo que aplicado sua carga máxima
suportada. O comando direcional que o movimenta para trás, demonstrou uma
execução inferior com relação ao seu giro inverso que o move para frente, portanto,
foi concluído que seria necessário adequar a programação do microcontrolador para
direcionar um PWM diferenciado para cada tipo de direcional do protótipo para
atingir um trabalho igualitário, independentemente do comando de velocidade
66
recebido. Por este motivo o controle de velocidade foi retirado do sistema
controlador do computador externo e o microcontrolador acabou reprogramado para
enviar um ciclo ativo de 100% para os motores, operando sempre em carga máxima.
O processo de simulações proporcionou que todo sistema controlador
desenvolvido fosse testado e colocado à prova sua execução completa. Este
processo de testes atingiu as expectativas demonstrando que o sistema de controle
funcionou corretamente, o que possibilitou posteriormente à placa de circuito
impresso ser confeccionada para ser utilizada na prática com o protótipo.
Devido a problemas técnicos na fabricação da placa e a ultrapassagem do
cronograma previsto, uma devida revisão ou reconstrução acabou sendo
impossibilitada, onde por este motivo a PCI não pode ser observada em
funcionamento controlando os motores no meio físico.
O resultado final do sistema de controle projetado não atingiu os objetivos
iniciais, que tinha como termino a utilização do circuito na prática para controlar o
ROV, embora foi concluído a partir dos testes virtuais que o sistema esta
funcionando corretamente.
5.1. Trabalhos Futuros
Em trabalhos futuros com as devidas adaptações na estrutura do ROV,

poderia ser acoplado ao veiculo a caixa de pressão, onde poderiam ser fixadas a
webcam e a placa de circuito impresso, para isso também seria necessário o estudo
e aprimoramento das técnicas de desenvolvimento de circuitos, e assim,
confeccionar uma nova PCI e realizar os devidos testes físicos de controle entre o
PC e os motores do ROV.
67
BIBLIOGRAFIA
CANZIAN, Edmur. Comunicação Serial - RS232; Cotia: CNZ Engenharia e
Informática Ltda, 2001.
DEMAMANN, Jonis Alves. RS-232 e Configuração da UART 16550A; acesso em

02 de maio de 2010. Disponível em:
http://www.inf.pucrs.br/~eduardob/disciplinas/ProgPerif/sem04.2/Seminarios/JonisDemaman
n/RS%20232%20e%20UART%2016550.htm
FRANKLIN, Marcelo. ROV - Robótica Submarina, acesso em 23 de junho de 2010.

Disponível em: http://marcelofranklin.blogspot.com/2009/09/rov-robotica-
submarina.html
MESSIAS, Antonio Rogério. USB/Serial – Controle de dispositivos; São Paulo:

Rogercom, 2005.
PUCRS. Porta Serial; acesso em 02 de maio de 2010. Disponível em:

http://www.ee.pucrs.br/~dbarros/d2005_1/Microproc/T2_Serial/porta_serial.html.
SILVA, Marcos Valério Costa. ROV - Robótica Submarina, acesso em 02 de maio

de 2010. Disponível em: http://www.webartigos.com/articles/25133/1/ROV-na-
Industria-do-Petroleo/pagina1.html
TORRES, Gabriel. Por Que Serial?; acesso em 16 de maio de 2010. Disponível em:
http://www.clubedohardware.com.br/artigos/726.
PONTES, Lelino. Curso de Robótica Aquática – ROV, acesso em 23 de junho de

2010. Disponível em: http://lelinopontes.wordpress.com/2010/09/03/curso-de-
roboica-aquatica-rov/
NICOMEX. Pré-sal impulsiona mercado de ROV, acesso em 30 de junho de 2010.

Disponível em: http://www.synergiaeditora.com.br/noticias/510-pre-sal-impulsiona-
mercado-de-rov
TECNOPEG. PRÉ-SAL IMPULSIONA MERCADO DE ROV, acesso em 30 de junho

de 2010. Disponível em: http://www.rrc-
robotica.com.br/site/index.php?option=com_content&view=article&id=47:pre-sal-impulsiona-
mercado-de-rov&catid=2:novasemdestaque&Itemid=17&lang=pt
SILVA, Marcos Valerio. ROV na Indústria do Petróleo, acesso em 30 de junho de

2010. Disponível em:
http://artigos.netsaber.com.br/resumo_artigo_20267/artigo_sobre_rov_na_industria_
do_petroleo
RRC. Veículos Submarinos de Operação Remota, acesso em 02 de julho de

2010. Disponível em: http://www.rrc-
robotica.com.br/site/index.php?option=com_content&view=article&id=11
68
VALERIO, Marcos. ROV na Indústria do Petróleo, acesso em 02 de julho de 2010.
Disponível em: http://www.webartigos.com/articles/25133/1/ROV-na-Industria-do-
Petroleo/pagina1.html
B.C.I.T. Underwater ROV System, acesso em 02 de julho de 2010. Disponível em:

http://www.marinetech.org/rov_competition/2009/technical_reports/explorer/BCIT_tec
hnical_report.pdf
GITIRANA, Geraldo L D Cartolano. Os ROV´s do Futuro, acesso em 02 de julho de

2010. Disponível em: http://diariotraineerov.blogspot.com/
ALEX. CABEAMENTO, acesso em 02 de julho de 2010. Disponível em:

http://www.alex.inf.br/uniuv/coltec/cabeamento.htm
FRANCO. Portas existentes nos PCs, acesso em 15 de julho de 2010. Disponível

em: http://www.francodigi.com/hardware/hard_portas.html
ROGERCOM, Curso USB/Serial, acesso em 15 de julho de 2010. Disponível em:

www.rogercom.com.br
Museu Virtual de informática. Fita Perfurada, acesso em 15 de julho de 2010.

Disponível em: http://piano.dsi.uminho.pt/museuv/cbaudot.html
CANZIAN, Edmur. Comunicação Serial - RS232, acesso em 15 de julho de 2010.

Disponível em: http://www.cnz.com.br
PUCRS. PORTA SERIAL, acesso em 15 de julho de 2010. Disponível em:

http://www.ee.pucrs.br/~dbarros/d2005_1/Microproc/T2_Serial/porta_serial.html
PUCRS. RS-232 e ConFiguração da UART 16550A, acesso em 15 de julho de

http://www.inf.pucrs.br/~eduardob/disciplinas/ProgPerif/sem04.2/Seminarios/JonisDe
mamann/RS%20232%20e%20UART%2016550.htm
SOARES, Luis Fernando G.; LEMOS, Guido; COLCHER, Sergio. Rede de

computadores, Editora: Campus, 2º Ed., Ano 1995
VINICIUS. Controle de Velocidade de motores DC, acesso em 15 de julho de

http://vinicius.brasil.vilabol.uol.com.br/eletronica/controlDCMotor1/controldcmotor1.ht
m
MICROCHIP, PICmicro™ Mid-Range MCU Family Reference Manual, acesso em

15 de julho de 2010. Disponível em:
http://ww1.microchip.com/downloads/en/devicedoc/33023a.pdf
TORRES, Gabriel. Por que Serial?, acesso em 15 de julho de 2010. Disponível em:
http://www.clubedohardware.com.br/artigos/726
69
MIRANDA, José Carlos. O REGULADOR DE VOLTAGEM, acesso em 15 de julho
de 2010. Disponível em: http://www.scribd.com/doc/14826195/o-Regulador-de-
Voltagem
Robótica Simples. RS01 - Câmera Robotizada, acesso em 15 de julho de 2010.

Disponível em: http://www.roboticasimples.com/projetos.php?acao=8
CARVALHOS, Andre. Sistemas Baseados em Microprocessadores, acesso em

http://www.fe.up.pt/si/disciplinas_geral.FormView?P_CAD_CODIGO=EEC0081&P_A
NO_LECTIVO=2007/2008&P_PERIODO=1S
Texas Instruments Incorporated. MAX232, MAX232I DUAL EIA-232

DRIVERS/RECEIVERS, acesso em 15 de julho de 2010. Disponível em:
http://www.datasheetarchive.com/search.php?q=MAX232&scanned=scan
SOARES, Márcio José. CONECTANDO UM MICROCONTROLADOR A UM PC,

acesso em 15 de julho de 2010. Disponível em:
http://www.arnerobotics.com.br/eletronica/comunicacao_rs232_PIC.htm
Robótica Simples. Introdução aos Microcontroladores, acesso em 15 de julho de

2010. Disponível em: http://www.roboticasimples.com/cursos.php?acao=12
ST Microelectronics. L298 DUAL FULL-BRIDGE DRIVER, acesso em 15 de julho de

http://www.datasheetcatalog.com/datasheets_pdf/L/2/9/8/L298.shtml
SOUZA, Vitor Amadeu. Programação em BASIC para o PIC Comunicação Serial,

acesso em 15 de julho de 2010. Disponível em: http://www.cerne-
tec.com.br/Artigo_12.pdf
PAULA, Bruno Marques de Faria. PROJETO DE UM TIME DE ROBÔS

AUTÔNOMOS, acesso em 15 de julho de 2010. Disponível em:
http://www.unifei.edu.br/iesti
RABELO, Bruno Soares. ROBÔS AUTONOMOS, acesso em 15 de julho de 2010.

Disponível em:
http://grupomorph.blogspot.com/search/label/Sum%C3%B4%20De%20Rob%C3%B
4s%20v1.0
PATSKO, Luís Fernando. TUTORIAL Montagem da Ponte H, acesso em 15 de

julho de 2010. Disponível em:
http://www.maxwellbohr.com.br/downloads/robotica/mec1000_kdr5000/tutorial_eletro
nica_-_montagem_de_uma_ponte_h.pdf
PNCA Robótca e Eletrônica LTDA. Entenda o PWM, acesso em 15 de julho de

70
http://www.pnca.com.br/index.php?option=com_content&view=article&id=67:pwm&c
atid=42:saiba-mais&Itemid=150
MALAQUIAS , Igor M. Modulador e demodulador PWM, acesso em 15 de julho de

2010. Disponível em: http://www.vespanet.com.br/~igor/pwm/arquivos/pwm.pdf
GUERREIRO , Júlio. Sistema de Controle de Potência de Motores DC, acesso em

http://ltodi.est.ips.pt/aabreu/motoresCC/relatoriomotoresCC.pdf
XINOX software. JCreator, acesso em 15 de julho de 2010. Disponível em:

http://www.jcreator.com/
MEDEIROS, Ernani. Desenvolvendo Software Com Uml, Editora Pearson Brasil,

Ed. 1, Ano 2004
ORENSTEIN, David. QuickStudy: Application Programming Interface (API),

acesso em 15 de julho de 2010. Disponível em:
http://www.computerworld.com/action/article.do?command=viewArticleBasic&articleI
d=43487
GOMES, Daniel Vasconcelos. Comunicação Serial Utilizando a API da SUN,

acesso em 20 de agosto de 2010. Disponível em:
http://www.guj.com.br/content/articles/javacommapi/JavaCommAPI.pdf
FURGERI, Sergio. Java 2: Ensino Didático: Desenvolvendo e Implementando

Aplicações, Editora Érica, Ed. 6, Ano 2002
JMF. Java Media Framework basics, acesso em 20 de agosto de 2010. Disponível

em: http://carfield.com.hk/document/java/tutorial/jmf_tutorial.pdf
Javafree.org. JMF - capturar imagens, acesso em 20 de agosto de 2010.

Disponível em: http://javafree.uol.com.br/viewtopic.jbb?t=852606
NETO, Oziel Moreira. Entendendo e Dominando o Java: para Internet, Editora

Digerati Books, 1ª Ed., Ano 2006
TERRA. Conheça as extensões de arquivos mais comuns, acesso em 20 de

agosto de 2010. Disponível em: http://tecnologia.terra.com.br/interna/0,,OI500589-
EI4804,00.html
PEREIRA, Fabio. Microcontrolador PIC Programação em C, Editora Érica Ltda,

Ed. 1, Ano 2003
Mecatronica.org. PROGRAMAS EXEMPLOS em C padrão CCS, acesso em 20 de

agosto de 2010. Disponível em:
http://www.mecatronica.org.br/disciplinas/cuscopic/prog/modelos/exemplos.htm
71
JEREK. Como Conectar O Proteus A Uma Porta De Comunicação, acesso em 20
de agosto de 2010. Disponível em:
http://www.asm51.eng.br/phpBB/viewtopic.php?t=69
BREIJO, Eduardo Garcia. Compilador C CCs Proteus E simulador, acesso em 20

de agosto de 2010. Disponível em:
http://www.marcombo.com/Descargas/9788426714954-
COMPILADOR%20C%20CCS%20Y%20SIMULADOR%20PROTEUS%20PARA%20
MICROCONTROLADORES%20PIC/descargar_primer_capitulo_libro_compiladorccc
s_simulador_proteus.pdf
KITOEAG. PWM com PIC, acesso em 20 de agosto de 2010. Disponível em:

http://www.youtube.com/watch?v=TyTwTUFKOt8
72
APÊNDICE A - Circuito Controlador
73
APÊNDICE B - Diagrama de Classe
74
APÊNDICE C - Programa do Computador externo
Casse MainInetrface
package init;
class MainInterface
{
public static void main(String args[])
{
LoadingInterface loading = new LoadingInterface();
}
}
Classe LoadingInterface
package init;
import javax.swing.*;
class LoadingInterface
{
LoadingInterface()
{
ArqDat arqDat = new ArqDat();
ParametrosBean parametrosBean = new ParametrosBean();

parametrosBean.setPortasIO(Comm.getPortasIO());
parametrosBean.setComandos(arqDat.getDatComandos());
parametrosBean.setComandosTeclado(arqDat.getDatComandosTeclado());
MenuInterface menuInterface = new MenuInterface();

menuInterface.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
menuInterface.setParametrosBean(parametrosBean);
menuInterface.setPortasIO();
menuInterface.setVisible(true);
}
}
Classe ArqDat
package init;
import java.io.*;
class ArqDat
{
protected void setDat(int Comandos[], int ComandosTeclado[])
{
75
try
{
FileOutputStream arq = new FileOutputStream("Configuracoes/Comandos.dat");
BufferedOutputStream buf = new BufferedOutputStream(arq);
DataOutputStream dado = new DataOutputStream(buf);
for(int i = 0; i < Comandos.length; i++)

dado.writeInt(Comandos[i]);
dado.close();
arq = new FileOutputStream("Configuracoes/ComandosTeclado.dat");

buf = new BufferedOutputStream(arq);
dado = new DataOutputStream(buf);
for(int i = 0; i < ComandosTeclado.length; i++)
dado.writeInt(ComandosTeclado[i]);
dado.close();
JOptionPane.showMessageDialog(null, "Configurações salvas com sucesso!",
":: Information ::",JOptionPane.INFORMATION_MESSAGE);
}
catch(java.io.IOException erro)
{
JOptionPane.showMessageDialog(null, "Erro ao gravar as configurações .dat",
":: Error ::", JOptionPane.ERROR_MESSAGE);
}
return;
}
protected int[] getDatComandos()

{
int Comandos[] = new int[9], cont = 0;
try
{
FileInputStream arq = new FileInputStream("Configuracoes/Comandos.dat");
BufferedInputStream buf = new BufferedInputStream(arq);
DataInputStream dado = new DataInputStream(buf);
while(true)
{
Comandos[cont] = dado.readInt();
cont++;
}
}
catch(java.io.EOFException err)
{
}
{
JOptionPane.showMessageDialog(null,"Erro ao salvar o arquivo \"Comandos.dat\"",
":: Error ::",JOptionPane.ERROR_MESSAGE);
76
}
return Comandos;
}
protected int[] getDatComandosTeclado()

{
int ComandosTeclado[] = new int[9], cont = 0;
try
{
FileInputStream arq = new FileInputStream("Configuracoes/ComandosTeclado.dat");
BufferedInputStream buf = new BufferedInputStream(arq);
DataInputStream dado = new DataInputStream(buf);
while(true)
{
ComandosTeclado[cont] = dado.readInt();
cont++;
}
}
catch(java.io.EOFException erro)
{
}
{
JOptionPane.showMessageDialog(null,"Erro ao salvar o arquivo
\"ComandosTeclado.dat\"",":: Error ::",JOptionPane.ERROR_MESSAGE);
}
return ComandosTeclado;
}
}
Classe Comm
package init;
import java.io.*;
import java.util.*;
import javax.comm.*;
class Comm
{
private static CommPortIdentifier portId = null;
private static SerialPort portSerial = null;
private static ParallelPort portParalela = null;
private static OutputStream outputStream = null;
protected static Vector getPortasIO()

{
Enumeration portList = CommPortIdentifier.getPortIdentifiers();
77
Vector PortasIO = new Vector();
while(portList.hasMoreElements())
{
portId = (CommPortIdentifier)portList.nextElement();
PortasIO.addElement(portId.getName());
}
return PortasIO;
}
protected static boolean getConexao(String Porta)

{
if(Porta.substring(0,3).equals("COM"))
{
if(getConexaoCOM(Porta) == true)
return true;
}
return false;
}
protected static boolean getConexaoCOM(String Porta)

{
try
{
portId = CommPortIdentifier.getPortIdentifier(Porta);
portSerial = (SerialPort)portId.open("Serial", 1000);
portSerial.setSerialPortParams(19200, portSerial.DATABITS_8,
portSerial.STOPBITS_1, portSerial.PARITY_NONE);
outputStream = portSerial.getOutputStream();
return true;
}
catch(NoSuchPortException erro)
{
JOptionPane.showMessageDialog(null,"Porta não encontrada!",":: Error ::",
JOptionPane.ERROR_MESSAGE);
}
catch(PortInUseException piu)
{
JOptionPane.showMessageDialog(null,"A porta já está sendo usada!",":: Error ::",
}
catch(UnsupportedCommOperationException uscoe)
{
JOptionPane.showMessageDialog(null,"Porta não suportada para controle!",":: Error
::",
}
{
78
JOptionPane.showMessageDialog(null,"Erro na comunicação 'OutputStream'!","::
Error ::",
}
return false;
}
protected static boolean getConexaoLPT(String Porta)

{
try
{
portId = CommPortIdentifier.getPortIdentifier(Porta);
portParalela = (ParallelPort)portId.open("Paralela", 1000);
portParalela.setMode(ParallelPort.LPT_MODE_SPP);
outputStream = portParalela.getOutputStream();
return true;
}
catch(NoSuchPortException erro)
{
JOptionPane.showMessageDialog(null,"Porta não encontrada!",":: Error
::",JOptionPane.ERROR_MESSAGE);
}
catch (PortInUseException piu)
{
JOptionPane.showMessageDialog(null,"A porta já está sendo usada!",":: Error
}
catch (UnsupportedCommOperationException uscoe)
{
JOptionPane.showMessageDialog(null,"Porta não suportada para controle!",":: Error
}
{
JOptionPane.showMessageDialog(null,"Erro na comunicação 'OutputStream'!","::
Error ::",JOptionPane.ERROR_MESSAGE);
}
return false;
}
protected static void setExecutaComando(String Comando)

{
try
{
outputStream.write(Comando.getBytes());
Thread.sleep(10);
outputStream.flush();
}
79
{
}
catch(InterruptedException erro)
{
}
}
protected static void setClose()

{
//Finaliza a conexão com a porta serial
if(portSerial != null)
{
portSerial.close(); portSerial = null;
}
//Encerra a instância de saída de dados
if(outputStream != null)
{
try
{
outputStream.close();
outputStream = null;
}
{
}
}
}
}
Classe ParametrosBean
package init;
import java.util.Vector;
class ParametrosBean implements java.io.Serializable

{
private Vector PortasIO;
private int Comandos[] = new int[9];
private int ComandosTeclado[] = new int[9];
public ParametrosBean()
{
}
public ParametrosBean(Vector PortasIO, int Comandos[], int ComandosTeclado[])

{
this.PortasIO = PortasIO;
this.Comandos = Comandos;
80
this.ComandosTeclado = ComandosTeclado;
}
public void setPortasIO(Vector PortasIO)

{
this.PortasIO = PortasIO;
}
public void setComandos(int Comandos[])

{
this.Comandos = Comandos;
}
public void setComandosTeclado(int ComandosTeclado[])

{
this.ComandosTeclado = ComandosTeclado;
}
public Vector getPortasIO()

{
return PortasIO;
}
public int[] getComandos()

{
return Comandos;
}
public int[] getComandosTeclado()

{
return ComandosTeclado;
}
}
Classe WebCam
package init;
import java.awt.*;
import java.awt.event.*;
import javax.media.*;
class WebCam
{
private static Component comp = null;
private static Player player = null;
protected static boolean getComponentWebCam()
81
{
try
{
CaptureDeviceInfo deviceInfo =
CaptureDeviceManager.getDevice("vfw:Logitech USB Video Camera:0");
MediaLocator mediaLocator = deviceInfo.getLocator();
player = Manager.createRealizedPlayer(mediaLocator);
player.start();
if((comp = player.getVisualComponent()) != null)
{
return true;
}
}
catch(Exception erro)
{
JOptionPane.showMessageDialog(null,erro.getMessage(),":: Error ::",
}
return false;
}
protected static Component getComponent()

{
//Retorna o Component 'comp'
return comp;
}
protected static void setClosePlayer()

{
if(player != null)
{
player.close();
player.deallocate();
player = null;
}
if(comp != null)
comp = null;
return;
}
}
Classe ControleInterface
package init;
import java.awt.*;
82
class ControleInterface extends JFrame implements ActionListener, KeyListener
{
//Components Swing
private TextField textFieldComandos[] = new TextField[9];
private TextField textFieldTeclado[] = new TextField[9];
private JButton buttonSalvar, buttonSair;
//Variaveis
private int Comandos[];
private int ComandosTeclado[];
//ParametroBeans
private ParametrosBean parametrosBean;
ControleInterface()
{
setTitle(":: ROV Submarino Interface :: Configurações de Controle");
setSize(450,300);
setResizable(false);
setLocation(420,300);
setIconImage(new ImageIcon("Imagens/Icone.png").getImage());
//JLabel
JLabel labelLogo = new JLabel(new ImageIcon("Imagens/Configuracoes.jpg"));
JLabel labelComando = new JLabel("Comandos");

JLabel labelValor = new JLabel("Valor");
JLabel labelTeclado = new JLabel("Teclado");
JLabel labelComandosInfo = new JLabel("Valor: Coluna onde deve ser definida a mensagem
que será enviada");
labelComandosInfo.setFont(new Font("Times New Roman", Font.PLAIN, 12));
JLabel labelTecladoInfo = new JLabel("Teclado: Teclas de atalho para executar os comandos");
labelTecladoInfo.setFont(new Font("Times New Roman", Font.PLAIN, 12));
JLabel label[] = new JLabel[9];

label[0] = new JLabel("Parar: ");
label[1] = new JLabel("Esquerda: ");
label[2] = new JLabel("Ré: ");
label[3] = new JLabel("Direita: ");
label[4] = new JLabel("Frente: ");
label[5] = new JLabel("Cima: ");
label[6] = new JLabel("Baixo: ");
label[7] = new JLabel("+ Velocidade: ");
label[8] = new JLabel("- Velocidade:");
//JTextField
for(int i = 0; i < 9; i++)
83
{
textFieldComandos[i] = new TextField(8);
textFieldTeclado[i] = new TextField(8);
textFieldTeclado[i].addKeyListener(this);
}
//JButton
buttonSalvar = new JButton("Salvar");
buttonSalvar.setToolTipText("Salvar Alterações");
buttonSalvar.setMnemonic(KeyEvent.VK_S);
buttonSalvar.addActionListener(this);
buttonSalvar.setContentAreaFilled(false);
buttonSalvar.setBorderPainted(true);
buttonSalvar.setFocusPainted(false);
buttonSair = new JButton("Sair");

buttonSair.setToolTipText("Sair");
buttonSair.setMnemonic(KeyEvent.VK_R);
buttonSair.addActionListener(this);
buttonSair.setContentAreaFilled(false);
buttonSair.setBorderPainted(true);
buttonSair.setFocusPainted(false);
JPanel panelWest = new JPanel();

panelWest.setLayout(new GridLayout());
panelWest.setBackground(Color.white);
panelWest.add(labelLogo);
JPanel panelSouth = new JPanel();

panelSouth.setLayout(new GridLayout(2,1));
panelSouth.setBackground(new Color(190,190,190));
panelSouth.add(labelComandosInfo);
panelSouth.add(labelTecladoInfo);
JPanel panelCenter = new JPanel();

panelCenter.setBorder(BorderFactory.createTitledBorder("Configurações de Controle "));
panelCenter.setLayout(new GridLayout(11,2));
panelCenter.setBackground(Color.white);
panelCenter.add(labelComando);
panelCenter.add(labelValor);
panelCenter.add(labelTeclado);
for(int i = 0; i < 9; i++)
{
panelCenter.add(label[i]);
panelCenter.add(textFieldComandos[i]);
panelCenter.add(textFieldTeclado[i]);
}
panelCenter.add(buttonSalvar);
panelCenter.add(buttonSair);
84
getContentPane().setLayout(new BorderLayout());
getContentPane().setBackground(Color.white);
getContentPane().add("West", panelWest);
getContentPane().add("Center", panelCenter);
getContentPane().add("South", panelSouth);
}
public void actionPerformed(ActionEvent e)

{
if(e.getSource() == buttonSalvar)
{
boolean status = setVerificaComandos();
if(status == true)
{
for(int i = 0; i < textFieldComandos.length; i++)
{
try
{
Comandos[i] =
Integer.parseInt(textFieldComandos[i].getText());
ComandosTeclado[i] =
Integer.parseInt(textFieldTeclado[i].getText());
}
catch(NumberFormatException erro)
{
}
}
setSaveDat();
parametrosBean.setComandos(Comandos);
parametrosBean.setComandosTeclado(ComandosTeclado);
MenuInterface menuInterface = new MenuInterface();
menuInterface.setParametrosBean(parametrosBean);
}
return;
}
if(e.getSource() == buttonSair)
{
dispose();
return;
}
}
public void keyPressed(KeyEvent e)

{
//Verifica em qual caixa de texto foi pressionado alguma tecla
//e em seguida atribui a mesma o seu código
85
if(e.getSource() == textFieldTeclado[0])
textFieldTeclado[0].setText("" + e.getKeyCode());
e.setKeyCode(e.VK_ESCAPE);
return;
}
public void keyReleased(KeyEvent e)
{
return;
}
public void keyTyped(KeyEvent e)
{
return;
}
private boolean setVerificaComandos()

{
for(int i = 0; i < textFieldComandos.length; i++)
for(int j = (i + 1); j < textFieldTeclado.length; j++)
{
try
{
if(Integer.parseInt(textFieldComandos[i].getText()) ==
Integer.parseInt(textFieldComandos[j].getText()) ||
textFieldTeclado[i].getText().equals(textFieldTeclado[j].getText()))
{
throw new Exception();
}
}
catch(Exception erro)
{
86
JOptionPane.showMessageDialog(null,"Erro ao validar as
configurações do controle:\n1. Verifique se há codigos em branco\n2. Verifique se há codigos repetidos","::
Error ::",JOptionPane.ERROR_MESSAGE);
return false;
}
}
return true;
}
private void setSaveDat()

{
ArqDat arqDat = new ArqDat();
arqDat.setDat(Comandos, ComandosTeclado);
return;
}
protected void setCarregaComandos()

{
for(int i = 0; i < Comandos.length; i++)
{
textFieldComandos[i].setText("" + Comandos[i]);
textFieldTeclado[i].setText("" + ComandosTeclado[i]);
}
return;
}
protected void setParametrosBean(ParametrosBean parametrosBean)

{
this.parametrosBean = parametrosBean;
Comandos = parametrosBean.getComandos();
ComandosTeclado = parametrosBean.getComandosTeclado();
}
}
Classe MenuInterface
package init;
import javax.swing.event.*;
import java.awt.*;
import java.util.*;
class MenuInterface extends JFrame implements ActionListener, MouseListener, KeyListener, FocusListener,

ChangeListener
{
//Swing
private JMenuBar menuBar;
87
private JMenu menuArquivo;
private JMenuItem menuItemConfiguracoes, menuItemSair;
private JPanel panelNorth, panelCenter, panelSouth, panelWebCam, panelDefaultWebCam,
panelComponentWebCam, panelControle;
private CardLayout panelCard;
private JLabel labelLogo, labelWebCam, labelStatusWebCam, labelSouth, labelPortas;
private JButton buttonConexao, buttonDriverCamera, buttonConfiguracoes, buttonControle[] = new
JButton[7];
private JToggleButton buttonTeclado;
private JComboBox comboPortas;
private JSlider slider;
//Variáveis
private int Comandos[];
private int ComandosTeclado[];
private int ComandoExecutado = 0, Velocidade = 0;
//Instância de Controle / ParametrosBean

private ControleInterface controleInterface = new ControleInterface();
private ParametrosBean parametrosBean;
MenuInterface()
{
setTitle(":: ROV Submarino Interface ::");
setSize(950,630);
setResizable(false);
setLocationRelativeTo(null);
setIconImage(new ImageIcon("Imagens/Icone.png").getImage());
//Barra de Menus
menuArquivo = new JMenu("Arquivo");
menuItemConfiguracoes = new JMenuItem("Configurações", new
ImageIcon("Imagens/Config2.jpg"));
menuItemConfiguracoes.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C,ActionEvent.ALT_MA
SK));
menuItemConfiguracoes.setMnemonic(KeyEvent.VK_C);
menuItemConfiguracoes.setBackground(Color.white);
menuItemConfiguracoes.addActionListener(this);
menuItemSair = new JMenuItem("Sair", new ImageIcon("Imagens/Sair.jpg"));
menuItemSair.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,ActionEvent.ALT_MASK));
menuItemSair.setMnemonic(KeyEvent.VK_S);
menuItemSair.setBackground(Color.white);
menuItemSair.addActionListener(this);
menuArquivo.add(menuItemConfiguracoes);
menuArquivo.addSeparator();
88
menuArquivo.add(menuItemSair);
menuBar = new JMenuBar();

menuBar.add(menuArquivo);
//PanelNorth
labelLogo = new JLabel(new ImageIcon("Imagens/Logo.jpg"));
panelNorth = new JPanel();

panelNorth.setLayout(new GridLayout());
panelNorth.setBorder(BorderFactory.createTitledBorder(""));
panelNorth.setBackground(Color.white);
panelNorth.add(labelLogo);
//PanelWebCam
labelWebCam = new JLabel(new ImageIcon("Imagens/WebCam.jpg"));
panelDefaultWebCam = new JPanel();

panelDefaultWebCam.setLayout(new GridLayout(1,0));
panelDefaultWebCam.setBackground(Color.white);
panelDefaultWebCam.add(labelWebCam);
panelComponentWebCam = new JPanel();

panelComponentWebCam.setLayout(new GridLayout());
panelComponentWebCam.setBackground(Color.white);
panelWebCam = new JPanel();

panelWebCam.setLayout(new CardLayout());
panelWebCam.setBackground(Color.white);
panelWebCam.setBorder(BorderFactory.createTitledBorder("WebCam "));
panelWebCam.add(panelDefaultWebCam, "Panel1");
panelWebCam.add(panelComponentWebCam, "Panel2");
panelCard = (CardLayout) panelWebCam.getLayout();

panelCard.first(panelWebCam);
//PanelControle
ImageIcon imageControle[] = getImageIconControle();
for(int i = 0; i < 7; i++)

{
buttonControle[i] = new JButton(imageControle[i]);
buttonControle[i].setContentAreaFilled(false);
buttonControle[i].setBorderPainted(true);
buttonControle[i].setFocusPainted(false);
buttonControle[i].addActionListener(this);
}
buttonControle[0].setToolTipText("Parar");
89
buttonControle[1].setToolTipText("Esquerda");
buttonControle[2].setToolTipText("Ré");
buttonControle[3].setToolTipText("Direita");
buttonControle[4].setToolTipText("Frente");
buttonControle[5].setToolTipText("Emergir");
buttonControle[6].setToolTipText("Submergir");
buttonTeclado = new JToggleButton("Teclado");

buttonTeclado.setBackground(new Color(220,220,220));
buttonTeclado.setToolTipText("Atalho de Controle");
buttonTeclado.setContentAreaFilled(true);
buttonTeclado.setBorderPainted(true);
buttonTeclado.setFocusPainted(false);
buttonTeclado.addFocusListener(this);
buttonTeclado.addKeyListener(this);
slider = new JSlider(JSlider.HORIZONTAL, 0, 4, 0);

slider.setBackground(Color.white);
slider.setForeground(Color.black);
slider.setMajorTickSpacing(1);
slider.setMinorTickSpacing(1);
slider.setPaintTicks(false);
slider.setPaintLabels(false);
slider.addChangeListener(this);
buttonControle[0].setBounds(30,25,50,35);
buttonTeclado.setBounds(330,30,90,30);
slider.setBounds(50,250,355,25);
panelControle = new JPanel();

panelControle.setBorder(BorderFactory.createTitledBorder("Controle "));
panelControle.setLayout(null);
panelControle.setBackground(Color.white);
panelControle.add(buttonControle[0]);
panelControle.add(buttonTeclado);
panelControle.add(slider);
90
//PanelCenter
labelStatusWebCam = new JLabel("Câmera Desconectada...");
labelStatusWebCam.setForeground(Color.red);
labelPortas = new JLabel("Portas I/O: ");

labelPortas.setFont(new Font("Arial", Font.BOLD, 12));
labelPortas.setForeground(Color.black);
comboPortas = new JComboBox();
buttonConexao = new JButton("Conectar");

buttonConexao.setBackground(Color.white);
buttonConexao.setContentAreaFilled(true);
buttonConexao.setBorderPainted(true);
buttonConexao.setFocusPainted(false);
buttonConexao.addActionListener(this);
buttonConexao.addMouseListener(this);
buttonConfiguracoes = new JButton(new ImageIcon("Imagens/Config.jpg"));

buttonConfiguracoes.setBackground(Color.white);
buttonConfiguracoes.setToolTipText("Configurações de Controle");
buttonConfiguracoes.setContentAreaFilled(true);
buttonConfiguracoes.setBorderPainted(true);
buttonConfiguracoes.setFocusPainted(false);
buttonConfiguracoes.addActionListener(this);
buttonDriverCamera = new JButton("WebCam");

buttonDriverCamera.setMnemonic(KeyEvent.VK_C);
buttonDriverCamera.setToolTipText("Carregar WebCam");
buttonDriverCamera.setContentAreaFilled(false);
buttonDriverCamera.setBorderPainted(true);
buttonDriverCamera.setFocusPainted(false);
buttonDriverCamera.addActionListener(this);
buttonDriverCamera.addMouseListener(this);
panelWebCam.setBounds(0,0,450,450);
buttonDriverCamera.setBounds(0,455,100,20);
labelStatusWebCam.setBounds(110,455,250,20);
labelPortas.setBounds(470,20,100,20);
comboPortas.setBounds(540,20,220,20);
buttonConexao.setBounds(790,20,120,20);
buttonConfiguracoes.setBounds(470,70,50,40);
panelControle.setBounds(470,170,450,280);
panelCenter = new JPanel();

panelCenter.setLayout(null);
panelCenter.add(panelWebCam);
panelCenter.add(buttonDriverCamera);
panelCenter.add(labelStatusWebCam);
91
panelCenter.add(labelPortas);
panelCenter.add(comboPortas);
panelCenter.add(buttonConexao);
panelCenter.add(buttonConfiguracoes);
panelCenter.add(panelControle);
//PanelSouth
labelSouth = new JLabel("UNIFAE :: São João da Boa Vista 2010 :: 1ª Turma de Engenharia da
Computação :: Trabalho de Conclusão de Curso :: Equipe de Controle :: Gustavo e Mateus");
panelSouth = new JPanel();

panelSouth.setLayout(new FlowLayout(FlowLayout.CENTER));
panelSouth.setBackground(new Color(200,200,200));
panelSouth.add(labelSouth);
//getContentPane()
setJMenuBar(menuBar);
getContentPane().setLayout(new BorderLayout());
getContentPane().add("North", panelNorth);
getContentPane().add("Center", panelCenter);
getContentPane().add("South", panelSouth);
setButtons(false);
}
//ActionListener
public void actionPerformed(ActionEvent e)
{
if(e.getSource() == menuItemConfiguracoes || e.getSource() == buttonConfiguracoes)
{
if(controleInterface.isVisible() == true)
controleInterface.dispose();
controleInterface = new ControleInterface();

controleInterface.setParametrosBean(parametrosBean);
controleInterface.setVisible(true);
WindowListener x = new WindowAdapter()
{
public void windowOpened(WindowEvent e)
{
controleInterface.setCarregaComandos();
}
};
controleInterface.addWindowListener(x);
return;
}
if(e.getSource() == menuItemSair)
{
WebCam.setClosePlayer();
92
Comm.setClose();
System.exit(0);
}
if(e.getSource() == buttonDriverCamera)
{
if(labelStatusWebCam.getText().equals("Câmera Desconectada..."))
setDriverWebCam();
else
setClosePlayer();
return;
}
if(e.getSource() == buttonConexao)
{
if(buttonConexao.getText().equals("Conectar"))
{
boolean conexao = Comm.getConexao("" + comboPortas.getSelectedItem());
if(conexao == true)
{
comboPortas.setEnabled(false);
buttonConexao.setText("Desconectar");
buttonConexao.setBackground(new Color(136,180,136));
setButtons(true);
}
}
else
if(buttonConexao.getText().equals("Desconectar"))
{
Comm.setClose();
comboPortas.setEnabled(true);
buttonConexao.setText("Conectar");
buttonConexao.setBackground(Color.white);
setButtons(false);
}
return;
}
if(e.getSource() == buttonControle[0])
{
setExecutaComando(Comandos[0]);
}
{
return;
}
{
return;
}
93
{
return;
}
{
return;
}
{
return;
}
{
return;
}
}
//MouseListener
public void mousePressed(MouseEvent e)
{
}
public void mouseEntered(MouseEvent e)
{
if(e.getSource() == buttonDriverCamera)
buttonDriverCamera.setCursor(new Cursor(Cursor.HAND_CURSOR));
if(e.getSource() == buttonConexao)
buttonConexao.setCursor(new Cursor(Cursor.HAND_CURSOR));
}
public void mouseExited(MouseEvent e)
{
}
public void mouseClicked(MouseEvent e)
{
}
public void mouseReleased(MouseEvent e)
{
}
//KeyListener
public void keyPressed(KeyEvent e)
{
if(e.getSource() == buttonTeclado)
{
if(buttonTeclado.isSelected() == true)
94
{
if(e.getKeyCode() == ComandosTeclado[0])
{
Velocidade = 1;
slider.setValue(slider.getValue() + 1);
}
{
Velocidade = 0;
slider.setValue(slider.getValue() - 1);
}
}
}
return;
}
public void keyReleased(KeyEvent e)
{
return;
}
public void keyTyped(KeyEvent e)
{
return;
}
//FocusListener
public void focusGained(FocusEvent e)
{
return;
}
public void focusLost(FocusEvent e)
{
buttonTeclado.setSelected(false);
}
//ChangeListener
95
public void stateChanged(ChangeEvent e)
{
if(Velocidade == 1)
else
}
//Metodos
private ImageIcon[] getImageIconControle()
{
ImageControleInterface image = new ImageControleInterface();
ImageIcon imageControle[] = image.getImageIconControle();
return imageControle;
}
private void setDriverWebCam()

{
boolean status = WebCam.getComponentWebCam();
if(status == true)
setComponent();
return;
}
private void setComponent()

{
panelComponentWebCam.add(WebCam.getComponent());
panelCard.show(panelWebCam,"Panel2");
labelStatusWebCam.setText("Câmera Conectada...");
labelStatusWebCam.setForeground(new Color(136,180,136));
return;
}
private void setClosePlayer()

{
WebCam.setClosePlayer();
panelCard.show(panelWebCam,"Panel1");
panelComponentWebCam.removeAll();
panelComponentWebCam.revalidate();
labelStatusWebCam.setText("Câmera Desconectada...");
labelStatusWebCam.setForeground(Color.red);
return;
}
protected void setPortasIO()

{
Vector PortasIO = parametrosBean.getPortasIO();
if(PortasIO == null)
comboPortas.addItem("Nenhuma Porta Disponível");
96
else
{
for(int i = 0; i < PortasIO.size(); i++)
comboPortas.addItem(PortasIO.get(i));
}
return;
}
private void setExecutaComando(int Comando)

{
if(ComandoExecutado == Comando && ComandoExecutado != Comandos[7] &&
ComandoExecutado != Comandos[8])
{
Comm.setExecutaComando("" + Comandos[0]);
ComandoExecutado = Comandos[0];
}
else
{
Comm.setExecutaComando("" + Comando);
ComandoExecutado = Comando;
}
return;
}
private void setButtons(boolean b)

{
buttonControle[0].setEnabled(b); buttonControle[1].setEnabled(b);
buttonControle[2].setEnabled(b);
buttonControle[3].setEnabled(b); buttonControle[4].setEnabled(b);
buttonControle[5].setEnabled(b);
buttonControle[6].setEnabled(b); buttonTeclado.setEnabled(b); slider.setEnabled(b);
return;
}
protected void setParametrosBean(ParametrosBean parametrosBean)

{
this.parametrosBean = parametrosBean;
Comandos = parametrosBean.getComandos();
ComandosTeclado = parametrosBean.getComandosTeclado();
}
}
Classe ImageControleInterface
package init;
class ImageControleInterface
97
{
protected ImageIcon[] getImageIconControle()
{
ImageIcon imageControle[] = new ImageIcon[7];
String Imagem = "";
for(int i = 0; i < 7; i++)
{
Imagem = "Imagens/Controle/Controle" + i + ".jpg";
imageControle[i] = new ImageIcon(Imagem);
}
return imageControle;
}
}
98
APÊNDICE D - Programa do microcontrolador
#include <16f877A.h>
#use delay(clock=4000000)
#fuses HS,PUT,NOWDT,NOBROWNOUT,NOLVP,NOPROTECT
#use rs232(BAUD=19200,parity=N,BITS=8,rcv=PIN_C7)
//Prototipo
void velocidade(int i);
//Variaveis
long int duty = 0;
void main(void)
{
setup_timer_2 (T2_DIV_BY_4, 255, 1);
setup_ccp1 (ccp_pwm);
set_pwm1_duty (1023);
set_tris_d(0b00000000);
output_d(0b00000010);
while(true)
{
if(kbhit())
{
switch(getc())
{
case '0': //Parar
output_d(0b00000010);
break;
case '1': //Esquerda
output_d(0b00001010);
break;
case '2': //Ré
output_d(0b01000110);
break;
case '3': //Direita
output_d(0b10000010);
break;
case '4': //Frente
output_d(0b10001010);
break;
case '5': //Pera cima
output_d(0b00100010);
break;
case '6': //Para baixo
output_d(0b00010010);
break;
99
case '7': //Aumenta Velocidade
//velocidade(1);
break;
case '8': //Diminui Velocidade
//velocidade(0);
break;
}
}
}
setup_ccp1(CCP_OFF);
}
//1 - Aumenta Velocidade

//0 - Diminui Velocidade
void velocidade(int i)
{
if(i == 1 && duty < 1020)
duty += 255;
else if(i == 0 && duty > 0)
duty -= 255;
set_pwm1_duty (duty);
}
100
APÊNDICE E - Simulação
101
102
103
104

TCC Rov

Enviado por

Direitos autorais:

Formatos disponíveis

TCC Rov

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

TCC Rov

Enviado por

Direitos autorais:

Formatos disponíveis

CENTRO UNIVERSITÁRIO DAS FACULDADES

COMUNICAÇÃO E CONTROLE DO ROV SUBAQUÁTICO

Gustavo Soquetti dos Reis

SÃO JOÃO DA BOA VISTA

COMUNICAÇÃO E CONTROLE DO ROV SUBAQUÁTICO

Trabalho apresentado a disciplina de

SÃO JOÃO DA BOA VISTA

Trabalho apresentado a disciplina de

Prof. M.Sc. Ramiro Romankevicius Costa – Orientador

Prof. M.Sc. Henrique Antônio Mielli Camargo – Examinador

Prof. Dr. Helder Anibal Hermini – Examinador

São João da Boa Vista, 10 de dezembro de 2010.

Gustavo Soquetti dos Reis:

Mateus Felipe Ramos:

Ao nosso professor orientador Ramiro Romankevicius Costa, pela paciência,

Um ROV (Remotely Operated Vehicle) é um veículo controlado remotamente,

Palavras Chave: ROV – Cordão Umbilical – Comunicação

An ROV (Remotely Operated Vehicle) is a remotely controlled vehicle, that

Keywords: ROV - Umbilical Cord - Communication

Figura 1: Modos de comunicação Simplex, Half-Duplex e Full-Duplex................................................. 12

Figura 2: Estrutura e Pinagem do conector DB9 de transmissão.......................................................... 14

Figura 3: Formatação de uma transmissão de 11 bits assíncronos ...................................................... 14

Figura 4: Sinal elétrico do padrão RS-232 ............................................................................................. 15

Figura 5: Fluxograma do módulo de interface do usuário.................................................................... 12

Figura 6: ROV e Modulo de controle da ferramenta............................................................................. 12

Figura 7: Fluxograma do módulo de controle de ferramenta............................................................... 12

Figura 8: Fluxograma do módulo de controle dos propulsores ............................................................ 12

Figura 9: Exemplo de mensagem enviada seguindo o código de Baudot............................................. 12

Figura 10: Sinal elétrico do caracter ‘P’ (10110 binários) ..................................................................... 24

Figura 11: Canais independentes de comunicação do modo Full-Duplex ............................................ 26

Figura 12: Exemplo de temporização para o tráfego de bits de dados ................................................ 27

Figura 13: Exemplo de mensagem enviada pelo tipo de comunicação assíncrono.............................. 28

Figura 14: Regulador de tensão do circuito .......................................................................................... 31

Figura 15: Funcionamento do Driver MAX232...................................................................................... 33

Figura 16 Pinagem do microcontrolador PIC 16F877A ......................................................................... 34

Figura 18: Funcionamento do CI L298................................................................................................... 37

Figura 19: Execução do segundo e terceiro comando de controle da Tabela 2 ................................... 39

Figura 20: Estrutura interna do CI L298 ................................................................................................ 39

Figura 21: Ponte H completa................................................................................................................. 40

Figura 22: Exemplo de um ciclo ativo em um determinado período de tempo ................................... 41

Figura 23: Exemplo de modulação para os motores propulsores ........................................................ 41

Figura 24: Método getPortasIO() .......................................................................................................... 45

Figura 25: Método getConexao() .......................................................................................................... 45

Figura 27: Método setExecutaComando() ............................................................................................ 47

Figura 28: Método getComponentWebCam() ...................................................................................... 48

Figura 29: Interface de configuração dos parâmetros de controle ...................................................... 50

Figura 30: Método setParametrosBean().............................................................................................. 52

Figura 31: Método actionPerformed() .................................................................................................. 53

Figura 32: Interface Visual..................................................................................................................... 55

Figura 33: Linhas de configurações do sistema do microcontrolador .................................................. 57

Figura 34: Loop Eterno .......................................................................................................................... 59

Figura 35: Pinagem dos controles direcionais dos motores ................................................................. 60

Figura 36: Configuração da comunicação serial do componente COMPIM ......................................... 64

Tabela 1: Especificações dos motores do protótipo ............................................................................. 29

Tabela 2: Controle analógico dos motores ........................................................................................... 38

Tabela 3: Configuração dos fusíveis do microcontrolador.................................................................... 57

API Application Programming Interface

Este trabalho consiste em desenvolver um sistema de comunicação, para o

A comunicação será composta por um cordão umbilical de cabos preparados