Embed Size (px)
Citation preview
Trabalho de Graduação
SISTEMA DE CONTROLE VEICULAR ATRAVÉS DE PROCESSAMENTO DE IMAGEM
Diogo do Nascimento Serra
Sorocaba – SP 2010
UNESP - Universidade Estadual Paulista “Júlio de Mesquita Filho”
Campus de Sorocaba
DIOGO DO NASCIMENTO SERRA
Trabalho de Graduação
SISTEMA DE CONTROLE VEICULAR ATRAVÉS DE PROCESSAMENTO DE IMAGEM
Dissertação apresentada à Universidade Estadual Paulista, Campus Experimental de Sorocaba, como requisito à obtenção do título de Bacharel no curso de Engenharia de Controle e Automação.
Orientador: Prof. Dr. Galdenoro Botura Jr.
Sorocaba - SP 2010
DIOGO DO NASCIMENTO SERRA
SISTEMA DE CONTROLE VEICULAR ATRAVÉS DE PROCESSAMENTO DE IMAGEM
Dissertação apresentada à Universidade Estadual Paulista, Campus Experimental de Sorocaba, como requisito à obtenção do título de Bacharel no curso de Engenharia de Controle e Automação.
Aprovado em: ____/____/____
BANCA EXAMINADORA
________________________________________________ Prof. Dr. Galdenoro Botura Jr.
(Orientador)
________________________________________________
Profª. Drª. Marilza Antunes de Lemos
________________________________________________ Eng. Me. Bruno Gianelli
Agradecimentos
Aos meus pais Humberto e Jacira que são os eternos responsáveis pela
criação da minha base e personalidade. Por motivos mais do que óbvios, são as
pessoas mais importantes ao longo dos anos e são os exemplos que sigo para
buscar vencer os desafios e atingir meus objetivos.
Aos meus irmãos Hugo e Tiago, amigos fiéis que sempre estiveram à minha
disposição para tudo que precisei, independente da situação. As conversas e o
apoio que tive deles foram essenciais para manter-me focado.
Aos meus companheiros de faculdade, que dividiram esses anos de estudos,
diversões e preocupações da melhor maneira possível, engrandecendo-me como
pessoa. Em especial aos amigos Alyson Ferolla, Fernando Cleber e Leonardo
Afonso, que ajudaram-me na realização deste projeto.
Aos amigos Caio, Danilo, Leonardo e Bruno, que além de colegas de
faculdade foram também companheiros de república durante minha estadia em
Sorocaba. Foi com eles que passei a maior parte dos tempos de estudos e aprendi a
conviver harmoniosamente.
Aos demais familiares e amigos, que, na sua maioria, mesmo estando longe,
sempre me apoiaram e incentivaram para que eu pudesse atingir meus objetivos.
Ao meu orientador Galdenoro Botura Jr. que desde o principio acreditou na
idéia do projeto e incentivou-me a buscar as melhores soluções para os problemas
encontrados. Esteve sempre disposto a conversar e ajudar em tudo que foi preciso
para que o projeto fosse concluído.
Aos demais docentes e funcionários da UNESP – Sorocaba, pelos
ensinamentos, apoio e serviços prestados ao longo da minha permanência na
universidade. Valores tais que me permitiram obter o melhor aprimoramento
acadêmico.
1
Resumo
Existem no mundo atual diversas situações onde a presença do ser humano
pode ser considerada de risco. Grutas, cavernas, campos de guerras – ativados ou
não -, minas etc. Porém, muitas vezes é necessário que estes ambientes sejam
explorados. Surge então a necessidade de se encontrar uma solução segura e
eficiente para que se possa conhecer e transpor os ambientes críticos sem que
nenhuma vida seja ameaçada. Ainda, o avanço rápido e constante da tecnologia
fornece cada vez mais recursos diversos que podem ser utilizados a fim de se criar
projetos que visem solucionar problemas da sociedade. Neste contexto, o presente
trabalho tem como propósito criar um veículo que possa ser controlado
remotamente, através da emissão de imagens pelo carro e de comandos de
movimentação enviados por computador, utilizando-se dos recursos de redes sem
fio.
2
Abstract
There are many situations in today’s world where the humans’ presence can
be considered dangerous. Caves, fields of war – on or not -, mines etc. However, it’s
often necessary that these environments be explored. So, exist a need to find a safe
and efficient solution that people can know and transpose the critical
environments without any life be threatened. Moreover, the fast and constant
advance of technology provides more and more diverse resources that can be used
in order to create projects designed to solve society’s problems. In this context, this
work aims to create a vehicle that can be controlled remotely by sending images of
the car and drive commands sent by computer, using the resources of wireless
networks.
3
Sumário Objetivo ......................................................................................................................................... 5
Lista de Figuras .............................................................................................................................. 6
Lista de Tabelas ............................................................................................................................. 7
Introdução ..................................................................................................................................... 8
Revisão Teórica ............................................................................................................................. 9
Protocolo TCP/IP ....................................................................................................................... 9
Introdução ............................................................................................................................. 9
Camada de Aplicação .......................................................................................................... 13
Camada de Transporte ........................................................................................................ 14
Camada Internet ................................................................................................................. 16
Camada Interface com a Rede ............................................................................................ 19
Serviços de Terminal ........................................................................................................... 21
TFTP (Trivial File Transfer Protocol) ..................................................................................... 22
DHCP (Dynamic Host Configuration Protocol) .................................................................... 23
DNS (Domain Name System) ............................................................................................... 24
ICMP (Internet Control Message Protocol) ......................................................................... 25
Protocolos de Roteamento: RIP, OSPF e BGP ..................................................................... 26
ARP e RARP .......................................................................................................................... 29
Outras Funcionalidades e Protocolos .................................................................................. 30
Redes wireless ......................................................................................................................... 31
Introdução ........................................................................................................................... 31
Topologia básica .................................................................................................................. 31
Tipos de placas .................................................................................................................... 35
Alcance e interferência ....................................................................................................... 36
Padrões ................................................................................................................................ 40
Potência de transmissão e alcance ..................................................................................... 41
Calculando a potência ......................................................................................................... 42
Calculando a distância ......................................................................................................... 44
Usando repetidores ............................................................................................................. 46
Especificações do Sistema ........................................................................................................... 49
Desenvolvimento ........................................................................................................................ 50
Componentes utilizados e seus custos.................................................................................... 50
Instalação e programação da câmera ..................................................................................... 51
4
Mapeamento e utilização dos sinais do carro ......................................................................... 56
Instalação e configuração da placa ......................................................................................... 57
Instalação e configuração do Access Point ............................................................................. 72
Alimentação do sistema .......................................................................................................... 75
Montagem do veículo ............................................................................................................. 76
Utilização de Joystick ............................................................................................................... 78
Resultados ................................................................................................................................... 81
Conclusão .................................................................................................................................... 83
Anexo 1 ........................................................................................................................................ 84
Anexo 2 ...................................................................................................................................... 125
Anexo 3 ...................................................................................................................................... 169
Anexo 4 ...................................................................................................................................... 180
Anexo 5 ...................................................................................................................................... 189
Anexo 6 ...................................................................................................................................... 205
Anexo 7 ...................................................................................................................................... 214
Bibliografia ................................................................................................................................ 234
5
Objetivo
O objetivo deste projeto é desenvolver um sistema remoto que possa controlar
um veículo a partir de imagens geradas com uma câmera localizada no mesmo. Projetar-
se-á um carro equipado com os dispositivos necessários para que a comunicação entre o
mesmo e um computador possa ser realizada. Ainda, a comunicação entre o veículo e a
maquina será feita de forma wireless, permitindo assim que o mesmo tenha total
mobilidade.
6
Lista de Figuras
Figura 1 - Arquitetura do TCP/IP ................................................................................... 12
Figura 2 - Como a camada de Aplicação funciona. ........................................................ 14
Figura 3 - Pacote de dados na camada de Transporte..................................................... 15
Figura 4 - Datagrama na camada de Internet. ................................................................. 18
Figura 5 - Fragmentação de datagrama. ......................................................................... 19
Figura 6 - Arquitetura da Ethernet .................................................................................. 20
Figura 7 - Quadro na camada de interface com a rede. .................................................. 21
Figura 8 - Ligação de uma rede wireless a uma cabeada. .............................................. 33
Figura 9 - Exemplificação de uma rede wireless. ........................................................... 47
Figura 10 - Exemplo de uso de repetidores em redes wireless. ...................................... 48
Figura 11 - Diagrama de blocos do sistema desenvolvido ............................................. 50
Figura 12 - janela de interface do IP Camera Finder. ..................................................... 51
Figura 13 - Tela de localização das câmeras. ................................................................. 52
Figura 14 - Tela com dados de endereço da câmera....................................................... 52
Figura 15 - página de seleção de navegador do programa de utilização da câmera. ...... 53
Figura 16 - página inicial do programa da câmera. ........................................................ 53
Figura 17 - página de configurações da câmera, ............................................................ 54
Figura 18 - tela de alteração da porta usada pela câmera. .............................................. 55
Figura 19 - Tela para configuração de senha para câmera. ............................................ 55
Figura 20 - placa do circuito integrado do carro de controle remoto. ............................ 57
Figura 21 - página de download do cd para a placa do kit. ............................................ 58
Figura 22 - Tela inicial do programa de instalação da placa do kit Renesas. ................. 58
Figura 23 - Foto da placa do kit Renesas........................................................................ 59
Figura 24 - Esquemático da placa do kit Renesas. ......................................................... 59
Figura 25 - Tela de boas vindas do programa HEW. ..................................................... 60
Figura 26 - Escolha do projeto a ser aberto pelo programa. ........................................... 61
Figura 27 - Seleção do kit correto pelo programa HEW. ............................................... 61
Figura 28 - Configurações básicas e escolha do exemplo 5. .......................................... 62
Figura 29 - página original do exemplo 5 do kit Renesas. ............................................. 62
Figura 30 - Nova página a ser usada no programa do carro. .......................................... 63
Figura 31 - Tela inicial do programa Bin2C_Win .......................................................... 64
Figura 32 - Indicação dos leds na placa Renesas............................................................ 66
7
Figura 33 - Localização dos botões Build All e Reset Go.............................................. 69
Figura 34 - Localização dos botões Connect e Disconnect. ........................................... 70
Figura 35 - Modificações para gravação de programa na memória. .............................. 70
Figura 36 - Conectores de alimentação e de rede da placa. ............................................ 71
Figura 37 - Conexões dos leds da placa Renesas. .......................................................... 72
Figura 38 - página inicial de configuração do Access Point. ......................................... 73
Figura 39 - Configuração no modo cliente e escolha da rede. ....................................... 74
Figura 40 - Configuração de senha do Access Point. ..................................................... 74
Figura 41 - Bateria de 9V convencional. ........................................................................ 75
Figura 42 - Conector para dispositivos usados no carro. ................................................ 75
Figura 43 - Bateria de 6V usada no circuito. .................................................................. 76
Figura 44 - Representação do circuito regulador de tensão............................................ 76
Figura 45 - Chassi de apoio. ........................................................................................... 77
Figura 46 - Conexão entre os dois chassis. ..................................................................... 77
Figura 47 - Vista lateral do veículo montado. ................................................................ 78
Figura 48 - Vista superior do veículo montado. ............................................................. 78
Figura 49 - Controle de XBOX 360. .............................................................................. 78
Figura 50 - Tela inicial do programa Xpadder. .............................................................. 79
Figura 51 - Tela para escolha de função. ........................................................................ 79
Figura 52 - Botões programados para o projeto do carro. .............................................. 80
Lista de Tabelas
Tabela 1 - relação de decibéis com miliwatts ................................................................. 41
Tabela 2 - Relação de perda em decibéis por distância .................................................. 44
Tabela 3 - valores de referência para taxas de transmissão ............................................ 45
Tabela 4 - Função e código dos botões da página HTML. ............................................. 63
Tabela 5 - Relação dos movimentos do veículo com os leds reais da placa. ................. 67
Tabela 6 - Relação de botões e respectivas funções. ...................................................... 80
8
Introdução
Existem e sempre existiram lugares e situações onde a presença do ser humano
pode ser considerada um risco. Campos de batalha – desativados ou não – com
constante presença de minas terrestres, cavernas, grutas, minas de exploração de
minérios, construções com estrutura fragilizada, com risco de desabamento, locais de
alta temperatura, entre outros, que podem causar acidentes fatais.
Sabe-se também que a tecnologia cresce rapidamente, havendo sempre novos
recursos disponíveis cada vez melhores e mais acessíveis, gerando uma imensurável
gama de possibilidades a serem lapidadas.
Com a existência das circunstâncias de risco e com o alicerce das ferramentas
tecnológicas disponíveis, busca-se a criação de um mecanismo que permita que as
situações possam ser enfrentadas sem que o ser humano sofra qualquer dano físico.
Sabe-se que alguns países e entidades já detêm algum conhecimento a cerca
desta situação, como as Forças Armadas dos Estados Unidos, possuidoras de alguns
equipamentos capazes de solucionar os problemas derivados destas condições de risco.
Porém, na maioria dos casos, os detentores deste conhecimento apenas os tornam
acessíveis a quem pertence às equipes criadoras. E quando permitem que estes
equipamentos sejam usufruídos por todos, os fazem com preços extremamente altos.
Em detrimento destes fatos, trabalhou-se no estudo e criação de um veículo que
possa ser controlado à distância, através da utilização de um computador, que
processará as imagens vindas do veículo – captadas por uma câmera -, utilizando de
tecnologia sem fio para transmissão das imagens e dos comandos de movimentação ao
veículo.
9
Revisão Teórica
Protocolo TCP/IP
Introdução
O TCP/IP é o protocolo de rede mais usado atualmente. Um protocolo é uma
linguagem usada para permitir que dois ou mais computadores se comuniquem. Assim
como acontece no mundo real, se eles não falarem a mesma língua, não podem se
comunicar [1].
Porém, antes das explicações sobre o mesmo serem feitas, será apresentado o
modelo OSI. Tal modelo é usado como referência para os demais protocolos, e neste
estudo serve como base de comparação para o modelo TCP/IP.
O modelo OSI é dividido em sete camadas. A idéia básica do modelo de
referência OSI é: cada camada é responsável por algum tipo de processamento e cada
camada apenas se comunica com a camada imediatamente inferior ou superior. Por
exemplo, a camada 6 só poderá se comunicar com as camadas 7 e 5, e nunca
diretamente com a camada 1. O que é importante ter em mente é que cada camada
adiciona (quando o computador estiver transmitindo dados) ou remove (quando o
computador estiver recebendo dados) informações de controle de sua responsabilidade.
Abaixo tem-se breves definições de cada camada.
Camada 7 – Aplicação: A camada de aplicação faz a interface entre o programa
que está enviando ou recebendo dados e a pilha de protocolos. Quando se está baixando
ou enviando e-mails, o programa de e-mail entra em contato com esta camada.
Camada 6 – Apresentação: Também chamada camada de Tradução, esta camada
converte o formato do dado recebido pela camada de Aplicação em um formato comum
a ser usado pela pilha de protocolos. Por exemplo, se o programa está usando um código
de página diferente do ASCII, esta camada será a responsável por traduzir o dado
recebido para o padrão ASCII. Esta camada também pode ser usada para comprimir
e/ou criptografar os dados. A compressão dos dados aumenta o desempenho da rede, já
que menos dados serão enviados para a camada inferior (camada 5). Se for utilizado
10
algum esquema de criptografia, os os dados circularão criptografados entre as camadas
5 e 1 e serão descriptografadas apenas na camada 6 no computador de destino.
Camada 5 – Sessão: Esta camada permite que dois programas em computadores
diferentes estabeleçam uma sessão de comunicação. Nesta sessão, esses dois programas
definem como será feita a transmissão dos dados e coloca marcações nos dados que
estão sendo transmitidos. Se porventura a rede falhar, os dois computadores reiniciam a
transmissão dos dados a partir da última marcação recebida em vez de retransmitir todos
os dados novamente. Por exemplo, você está baixando e-mails de um servidor de e-
mails e a rede falha. Quando a rede voltar a estar operacional, a tarefa continuará do
ponto em que parou, não sendo necessário reiniciá-la.
Camada 4 – Transporte: Nas redes de computadores os dados são divididos em
vários pacotes. Quando se está transferindo um arquivo grande, este arquivo é dividido
em vários pequenos pacotes. No computador receptor, esses pacotes são organizados
para formar o arquivo originalmente transmitido. A camada de Transporte é responsável
por pegar os dados enviados pela camada de Sessão e dividi-los em pacotes que serão
transmitidos pela rede. No computador receptor, a camada de Transporte é responsável
por pegar os pacotes recebidos da camada de Rede e remontar o dado original para
enviá-lo à camada de Sessão. Isso inclui controle de fluxo (colocar os pacotes recebidos
em ordem, caso eles tenham chegado fora de ordem) e correção de erros, tipicamente
enviando para o transmissor uma informação de reconhecimento (acknowledge),
informando que o pacote foi recebido com sucesso. A camada de Transporte separa as
camadas de nível de Aplicação (camadas 5 a 7) das camadas de nível Rede (camadas de
1 a 3).
Camada 3 – Rede: Esta camada é responsável pelo endereçamento dos pacotes,
convertendo endereços lógicos em endereços físicos, de forma que os pacotes consigam
chegar corretamente ao destino. Essa camada também determina a rota que os pacotes
irão seguir para atingir o destino, levando em consideração fatores como condições de
tráfego da rede e prioridades.
Camada 2 – Link de Dados: Essa camada (também chamada camada de Enlace)
pega os pacotes de dados recebidos da camada de rede e os transforma em quadros que
serão trafegados pela rede, adicionando informações como o endereço da placa de rede
11
de origem, o endereço da placa de rede de destino, dados de controle, os dados em si e
uma soma de verificação, também conhecida como CRC. O quadro criado por esta
camada é enviado para a camada Física, que converte esse quadro em sinais elétricos
(ou sinais eletromagnéticos, em caso de rede sem fio) para serem enviados através do
cabo de rede. Quando o receptor recebe um quadro, a sua camada de Link de Dados
confere se o dado chegou íntegro, refazendo a soma de verificação (CRC). Se os dados
estiverem o.k., ele envia uma confirmação de recebimento (chamada acknowledge ou
simplesmente ack). Caso essa confirmação não seja recebida, a camada Link de Dados
do transmissor reenvia o quadro, já que ele não chegou até o receptor ou então chegou
com os dados corrompidos.
Camada 1 – Física: Esta camada pega os quadros enviados pela camada de Link
de Dados e os transforma em sinais compatíveis com o meio onde os dados deverão ser
transmitidos. Se o meio for elétrico, essa camada converte os 0s e 1s dos quadros em
sinais elétricos a serem transmitidos pelo cabo; se o meio for óptico (uma fibra óptica),
essa camada converte os 0s e 1s dos quadros em sinais luminosos; se uma rede sem fio
for usada, então os 0s e 1s são convertidos em sinais eletromagnéticos; e assim por
diante. No caso da recepção de um quadro, a camada física converte os sinais do cabo
em 0s e 1s e envia essas informações para a camada de Link de Dados, que montará o
quadro e verificará se ele foi recebido corretamente.
Agora, sobre o modelo TCP/IP. Este não é na verdade um protocolo, mas sim
um conjunto destes – uma pilha de protocolos, como ele é mais chamado. Seu nome,
por exemplo, já faz referência a dois protocolos diferentes, o TCP (Transmission
Control Protocol, Protocolo de Controle de Transmissão) e o IP (Internet Protocol,
Protocolo de Internet). Existem muitos outros protocolos que compõem a pilha TCP/IP,
como o FTP, o HTTP, o SMTP e o UDP [1].
A arquitetura do TCP/IP pode ser vista na Figura 1.
12
Figura 1 - Arquitetura do TCP/IP
Como pode ser visto, o TCP/IP tem quatro camadas. Os programas, no
computador, se comunicam com a camada de Aplicação. Nesta camada encontrar-se-ão
os protocolos de aplicação tais como o SMTP (para e-mail), o FTP (para a transferência
de arquivos) e o HTTP (para navegação web). Cada tipo de programa se comunica com
um protocolo de aplicação diferente, dependendo da finalidade do programa [1].
Após processar a requisição do programa, o protocolo na camada de Aplicação
se comunicará com outro protocolo na camada de Transporte, normalmente o TCP. Esta
camada é responsável por receber os dados enviados pela camada superior, dividi-los
em pacotes e enviá-los para a camada imediatamente inferior, ou seja, a camada
Internet. Além disso, durante a recepção dos dados, esta camada é responsável por
ordenar os pacotes recebidos da rede (já que eles podem chegar fora de ordem) e
também verificam se o conteúdo dos pacotes está intacto [1].
Na camada Internet nós temos o IP (Internet Protocol, Protocolo Internet), que
pega os pacotes recebidos da camada de Transporte e adiciona informações de
endereçamento virtual, isto é, adiciona o endereço do computador que está enviando os
dados e o endereço do computador que receberá os dados. Estes endereços virtuais são
chamados endereços IP. Em seguida, os pacotes são enviados para a camada Interface
com a Rede. Nesta camada os pacotes são chamados datagramas [1].
13
A camada Interface com a Rede receberá os pacotes enviados pela camada
Internet e os enviará para a rede (ou receberá os dados da rede, caso o computador
esteja recebendo dados). O que está dentro desta camada dependerá do tipo de rede que
o computador estiver usando. Atualmente, praticamente todos os computadores utilizam
um tipo de rede chamado Ethernet (que está disponível em diferentes velocidades; as
redes sem fio também são redes Ethernet) e, portanto, deve-se encontrar na camada
Interface com a Rede as camadas da Ethernet, que são Controle do Link Lógico (LLC),
Controle de Acesso ao Meio (MAC) e Física. Os pacotes transmitidos pela rede são
chamados quadros [1].
Camada de Aplicação
Esta camada faz a comunicação entre os programas e os protocolos de
transporte. Existem vários protocolos que operam na camada de aplicação. Os mais
conhecidos são o HTTP (HyperText Transfer Protocol, Protocolo de Transferência
Hipertexto), o SMTP (Simple Mail Transfer Protocol, Protocolo Simples de
Transferência de Correspondência), o FTP (File Transfer Protocol, Protocolo de
Transferência de Arquivos), o SNMP (Simple Network Management Protocol,
Protocolo Simples de Gerenciamento de Redes), o DNS (Domain Name System,
Sistema de Nome de Domínio) e o Telnet [1].
Quando um programa cliente de e-mail quer receber os e-mails que estão
armazenados no servidor de e-mail, o mesmo efetuará esse pedido para a camada de
aplicação do TCP/IP, sendo atendido pelo protocolo SMTP. Quando se entra num
endereço “www” no navegador para visualizar uma página na Internet, o mesmo se
comunicará com a camada de aplicação do TCP/IP, sendo atendido pelo protocolo
HTTP (é por isso que as páginas da Internet começam com http://). E assim por diante
[1].
A camada de aplicação comunica-se com a camada de transporte através de uma
porta. As portas são numeradas e as aplicações padrão usam sempre uma mesma porta.
Por exemplo, o protocolo SMTP utiliza sempre a porta 25, o protocolo HTTP utiliza
sempre a porta 80 e o FTP as portas 20 (para transmissão de dados) e 21 (para
transmissão de informações de controle) [1].
14
O uso de um número de porta permite ao protocolo de transporte (tipicamente o
TCP) saber qual é o tipo de conteúdo do pacote de dados (por exemplo, saber que o
dado que ele está transportando é um e-mail) e, no receptor, saber para qual protocolo
de aplicação ele deverá entregar o pacote de dados, já que existem inúmeros. Assim, ao
receber um pacote destinado à porta 25, o protocolo TCP irá entregá-lo ao protocolo que
estiver conectado a esta porta, tipicamente o SMTP, que por sua vez entregará o dado à
aplicação que o solicitou (o programa de e-mail) [1].
Na Figura 2 ilustra-se como a camada de Aplicação funciona.
Figura 2 - Como a camada de Aplicação funciona.
Camada de Transporte
Na transmissão de dados, a camada de transporte é responsável por pegar os
dados passados pela camada de aplicação e transformá-los em pacotes. O TCP
(Transmission Control Protocol, Protocolo de Controle da Transmissão) é o protocolo
mais usado na camada de Transporte. Na recepção de dados, o protocolo TCP pega os
pacotes passados pela camada Internet e os coloca em ordem, confere se os dados
dentro dos pacotes estão íntegros e envia um sinal de confirmação chamado
“acknowledge” (“ack”) ao transmissor, avisando que o pacote foi recebido corretamente
e que os dados estão íntegros. Se nenhum sinal de confirmação (acknowledge) for
recebido (ou porque o dado não chegou ao destino ou porque o TCP descobriu que o
dado estava corrompido), o transmissor enviará novamente o pacote perdido [1].
Enquanto que o TCP reordena os pacotes e usa mecanismo de confirmação de
recebimento – o que é desejável na transmissão de dados – existe um outro protocolo
15
que opera nesta camada que não tem esses recursos. Este protocolo é o UDP (User
Datagram Protocol, Protocolo de Datagrama do Usuário) [1].
Por essa razão o TCP é considerado um protocolo confiável, enquanto que o
UDP é considerado um protocolo não confiável. O UDP é tipicamente usado quando
nenhum dado importante está sendo transmitido, como requisições DNS (Domain Name
System, Sistema de Nome de Domínio). Como o UDP não reordena os pacotes e nem
usa mecanismo de confirmação, ele é mais rápido do que o TCP [1].
Quando o UDP é usado, a aplicação que solicita a transmissão será a responsável
por verificar se os dados recebidos estão intactos ou não e também de reordenar os
pacotes recebidos, isto é, a aplicação fará o trabalho do TCP [1].
Durante a transmissão de dados, tanto o UDP quanto o TCP receberão os dados
passados da camada de Aplicação e adicionarão a esses dados um cabeçalho. Na
recepção de dados, o cabeçalho será removido antes de os dados serem enviados para a
porta apropriada. Neste cabeçalho estão várias informações de controle, em particular o
número da porta de origem, o número da porta de destino, um número de seqüência
(para a confirmação de recebimento e mecanismos de reordenamento usado pelo TCP) e
uma soma de verificação (chamada checksum ou CRC, que é um cálculo usado para
verificar se o dado foi recebido intacto no destino). O cabeçalho UDP tem oito bytes,
enquanto que o cabeçalho TCP tem entre 20 e 24 bytes (dependendo se o campo opções
estiver sendo ou não usado) [1].
Na Figura 3 ilustra-se o pacote de dados gerado na camada de transporte. Este
pacote de dados será enviado para a camada Internet (se está transmitindo dados) ou
será recebido da camada Internet (se está recebendo dados) [1].
Figura 3 - Pacote de dados na camada de Transporte.
16
Camada Internet
Em redes TCP/IP cada computador é identificado com um endereço virtual
único, chamado endereço IP. A camada Internet é responsável por adicionar um
cabeçalho ao pacote de dados recebidos da camada de Transporte onde, entre outros
dados de controle, será adicionado também o endereço IP de origem e o endereço IP de
destino – isto é, o endereço IP do computador que está enviando os dados e o endereço
IP do computador que deverá recebê-los [1].
A placa de rede de cada computador tem um endereço físico. Este endereço está
gravado na memória ROM da placa de rede e é chamado endereço MAC. Dessa forma,
em uma rede local, se o computador A quiser enviar dados para o computador B, ele
precisará saber o endereço MAC do computador B. Enquanto que, em uma pequena
rede local os computadores podem facilmente descobrir o endereço MAC de todos os
computadores, o mesmo não pode ser dito em uma rede global como a Internet, por ser
uma tarefa mais complexa [1].
Se nenhum esquema de endereçamento virtual for usado, precisa se saber o
endereço MAC do computador de destino, o que não é apenas uma tarefa complicada,
mas também não ajuda no roteamento dos pacotes, já que este endereço não usa uma
estrutura em árvore (em outras palavras, enquanto o endereçamento virtual usado na
mesma rede terá endereços seqüenciais, com o endereçamento MAC, o computador
com o endereço MAC seguinte ao pode estar na Rússia) [1].
Roteamento é o caminho que os dados devem usar para chegar ao destino.
Quando se solicita dado de um servidor da Internet, por exemplo, este dado passa por
vários locais (chamados roteadores) antes de chegar ao computador [1].
Em todas as redes conectadas à Internet existe um dispositivo chamado roteador,
que faz a ponte entre os computadores na sua rede local e a Internet. Todo roteador tem
uma tabela contendo as redes conhecidas e também uma configuração chamada gateway
padrão apontando para outro roteador na Internet. Quando o computador envia um
pacote de dados para a Internet, o roteador conectado à rede primeiro verifica se ele
17
conhece o computador de destino – em outras palavras, o roteador verifica se o
computador de destino está localizado na mesma rede ou em uma rede que ele conhece
a rota. Se ele não conhecer a rota para o computador de destino, ele enviará o pacote
para seu gateway padrão, que é outro roteador. Este processo é repetido até que o pacote
de dados chegue ao seu destino [1].
O IP recebe os pacotes de dados recebidos da camada de Transporte (do
protocolo TCP, caso está-se transmitindo dados como e-mails ou arquivos) e os divide
em datagramas. O datagrama é um pacote que não contém nenhum tipo de confirmação
de recebimento (acknowledge), o que significa que o IP não implementa nenhum
mecanismo de confirmação de recebimento, isto é, ele é um protocolo não confiável [1].
Deve-se notar que durante a transferência de dados o protocolo TCP será usado
acima da camada Internet (ou seja, acima do IP) e o TCP implementará mecanismo de
confirmação de recebimento. Portanto apesar de o protocolo IP não verificar se o
datagrama chegou ao destino, o protocolo TCP fará esta verificação. A conexão será
então confiável, apesar do IP sozinho ser um protocolo não confiável [1].
Cada datagrama IP pode ter um tamanho máximo de 65.535 bytes, incluindo seu
cabeçalho, que pode usar 20 ou 24 bytes, dependendo se um campo chamado “opções”
for usado ou não. Dessa forma, os datagramas IP podem transportar até 65.515 ou
65.511 bytes de dados. Se o pacote de dados recebidos da camada de Transporte forem
maiores do que 65.515 ou 65.511 bytes, o protocolo IP fragmentará os pacotes em
quantos datagramas forem necessários [1].
Na Figura 4 ilustrou-se o datagrama gerado na camada Internet pelo protocolo
IP. É interessante notar que o que a camada Internet vê como sendo “dados” é o pacote
completo que ela recebe da camada de Transporte, que inclui o cabeçalho TCP ou UDP.
Este datagrama será enviado para a camada Interface com a Rede (se estiver
transmitindo) ou pode ter sido recebido da camada Interface com a Rede (se estiver
recebendo dados) [1].
18
Figura 4 - Datagrama na camada de Internet.
O datagrama IP pode ter até 65.535 bytes. Isto significa que o campo de dados
do datagrama não tem um tamanho fixo. Como os datagramas serão transmitidos pela
rede dentro de quadros produzidos pela camada Interface com a Rede, normalmente o
sistema operacional configurará o tamanho do datagrama IP para ter o tamanho máximo
da área de dados do quadro de dados usado na rede. O tamanho máximo do campo de
dados dos quadros que são transmitidos pela rede é chamado MTU, Maximum Transfer
Unit, ou Unidade de Transferência Máxima [1].
As redes Ethernet podem transportar até 1.500 bytes de dados, ou seja, seu MTU
é de 1.500 bytes. Por isso o sistema operacional configura automaticamente o protocolo
IP para criar datagramas IP com 1.500 bytes em vez de 65.535 (que não caberia no
quadro) [1].
O TCP/IP é um conjunto de protocolos que lida com as camadas 3 a 7 do
modelo de referência OSI. O Ethernet é um conjunto de protocolos que lida com as
camadas 1 e 2 do modelo de referência OSI – o que significa que o Ethernet se preocupa
com o aspecto físico da transmissão de dados. Por isso eles se complementam, já que
precisam-se das sete camadas completas (ou suas equivalentes) para estabelecer uma
conexão de rede [1].
Outra característica que o protocolo IP permite é a fragmentação. Até chegar a
seu destino, o datagrama IP provavelmente passará por várias outras redes no meio do
caminho. Se todas as redes no caminho entre o computador transmissor e o receptor
usarem o mesmo tipo de rede (por exemplo Ethernet), o funcionamento é otimizado, já
que todos os roteadores trabalharão com a mesma estrutura do quadro (isto é, o mesmo
tamanho de MTU) [1].
19
No entanto, se as outras redes não forem redes Ethernet, elas podem usar um
tamanho diferente de MTU. Se isto acontecer, o roteador que está recebendo os quadros
com o MTU configurado com 1.500 bytes dividirá o datagrama IP em quantos quadros
forem necessários para atravessar a rede com o tamanho de MTU menor. Ao chegar ao
roteador que tem sua saída conectada a uma rede Ethernet, este roteador remontará o
datagrama original [1].
Na Figura 5 pode-se ver um exemplo disto. O quadro original usa um MTU de
1.230 bytes. Quando o datagrama chega a uma rede com o tamanho de MTU de 620
bytes, cada quadro tem de ser dividido em três quadros (dois com 600 bytes e um com
30 bytes). Em seguida o roteador na saída desta rede (roteador 2) remonta o datagrama
original. Claro que o cabeçalho IP tem um cabo para controlar a fragmentação [1].
Figura 5 - Fragmentação de datagrama.
Camada Interface com a Rede
Os datagramas gerados na camada Internet serão passados para a camada
Interface com a Rede, durante a transmissão de dados, ou a camada de Interface com a
Rede pegará os dados da rede e os enviará para a camada de Internet, na recepção dos
dados [1].
Esta camada é definida pelo tipo de rede física a qual seu computador está
conectado. Quase sempre o computador estará conectado a uma rede Ethernet (redes
sem fio também são redes Ethernet) [1].
20
O Ethernet tem três camadas: LLC (Controle do Link Lógico), MAC (Controle
de Acesso ao Meio) e Física. O LLC e o MAC correspondem, juntas, a segunda camada
do modelo de referência OSI. Pode-se ver a arquitetura do Ethernet na Figura 6 [1].
Figura 6 - Arquitetura da Ethernet
A camada LLC é a responsável por adicionar informações de que protocolo na
camada Internet foi o responsável por gerar os dados. Dessa forma, durante a recepção
de dados da rede, esta camada no computador receptor tem que saber que protocolo da
camada de Internet ele deve entregar os dados. Esta camada é definida pelo protocolo
IEEE 802.2 [1].
A camada de Controle de Acesso ao Meio (MAC) é a responsável por montar o
quadro que será enviado para a rede. Esta camada é responsável por adicionar o
endereço MAC de origem e de destino. Os quadros que são destinados a outras redes
utilizarão o endereço MAC do roteador da rede como endereço de destino. Esta camada
é definida pelo protocolo IEEE 802.3, se uma rede com cabos estiver sendo usada, ou
pelo protocolo IEEE 802.11, se uma rede sem fio estiver sendo usada [1].
A camada Física é a responsável por converter o quadro gerado pela camada
MAC em sinais elétricos (se for uma rede cabeada) ou eletromagnéticos (se for uma
rede sem fio). Esta camada é também definida pelo protocolo IEEE 802.3, se for uma
rede com cabos estiver sendo usada, ou pelo IEEE 802.11, se uma rede sem fio estiver
sendo usada [1].
As camadas LLC e MAC adicionam suas informações de cabeçalho ao
datagrama recebido da camada Internet. Portanto uma estrutura completa de quadros
gerados por essas duas camadas pode ser vista na Figura 7. Nota-se que os cabeçalhos
21
adicionados pelas camadas superiores são vistos como “dados” pela camada LLC. A
mesma coisa acontece com o cabeçalho inserido pela camada LLC, que será visto como
dado pela camada MAC [1].
A camada LLC adiciona um cabeçalho de 3 ou 5 bytes e seus datagrama tem um
tamanho total máximo de 1.500 bytes, deixando um máximo de 1.497 ou 1.495 bytes
para dados. A camada MAC adiciona um cabeçalho de 22 bytes e um CRC (soma dos
dados para identificação de erros) de quatro bytes ao final do datagrama recebido da
camada LLC, formando o quadro Ethernet. Portanto o tamanho máximo de um quadro
Ethernet é de 1.526 bytes [1].
Figura 7 - Quadro na camada de interface com a rede.
Serviços de Terminal
Os serviços de terminal permitem que se acesse remotamente um servidor e
tenha acesso ao seu shell (isto é, seu prompt de comando) como se estivesse-se
fisicamente em frente ao teclado e ao monitor do servidor. Os três protocolos de
terminal mais comuns são o Telnet, o Rlogin e o SSH (Secure Shell). Todos fazem a
mesma coisa, mas as conexões do SSH são criptografadas e, por isso, mais seguras.
Caso tenha-se que gerenciar um servidor remotamente, opta-se por usar o SSH em vez
do Telnet ou do Rlogin. Como tanto as conexões Telnet quanto as conexões Rlogin não
são criptografadas, qualquer pessoa usando um programa de “sniffer” – que é um tipo
de programa que permite ao hacker ler os pacotes de dados que trafegam na rede – pode
ler tudo o que se digita, incluindo senhas [2].
22
O Telnet, o Rlogin e o SSH são protocolos da camada de aplicação e usam o
protocolo TCP na camada de transporte. O Telnet usa a porta 23, o Rlogin usa a porta
513 e o SSH usa a porta 22 [2].
TFTP (Trivial File Transfer Protocol)
O TFTP (Trivial File Transfer Protocol, Protocolo Trivial de Transferência de
Arquivo) é um protocolo que desempenha o mesmo tipo de aplicação que o FTP –
transferência de arquivos – mas ao contrário do mesmo, usa o protocolo UDP na
camada de transporte [2].
A diferença entre o TCP e o UDP é que enquanto o TCP verifica se cada pacote
chegou corretamente ao destino, o UDP não. Outra diferença é que o TCP reordena os
pacotes que podem ter chegado fora de ordem, enquanto que o UDP também não realiza
tal tarefa [2].
Por outro lado, por não usar mecanismos de confirmação e reordenamento de
pacotes, os pacotes UDP são menores (já que o cabeçalho UDP é menor do que o
cabeçalho TCP) e necessitam de menos poder computacional para serem processados –
já que os processos de reordenamento e confirmação de recebimento não são
necessários. Será a aplicação – e não o protocolo – que se encarregará de executar essas
funções [2].
Para aplicações cotidianas, o protocolo TFTP não tem muita utilidade, já que o
FTP é muito mais confiável. No entanto, existe um tipo de aplicação que tira proveito
do TFTP: o boot remoto [2].
Pode-se ter um computador sem disco rígido ou qualquer outra mídia de
armazenamento e configurá-lo para realizar o boot pela rede, isto é, carregar o sistema
operacional e programas a partir de um servidor. O programa que carregará o sistema
operacional remotamente precisa estar armazenado em uma pequena memória ROM,
localizada na placa de rede do computador sem mídia de armazenamento. Como este
processo necessita de um protocolo para transferência de arquivos, o TFTP é mais
indicado do que o FTP, já que os clientes TFTP são muito menores que os clientes FTP,
podendo ser armazenado na memória ROM da placa de rede. Para se ter uma idéia, o
tamanho do maior chip de memória ROM usado para boot remoto é de apenas 64 KB.
23
Em resumo, o TFTP é um protocolo da camada de aplicação que usa o protocolo UDP
(porta 69) na camada de transporte [2].
DHCP (Dynamic Host Configuration Protocol)
Todos os computadores conectados a uma rede TCP/IP precisam ser
configurados com um endereço IP. Sem um endereço IP um computador não pode se
comunicar com outros computadores da rede [2].
Em uma rede grande com centenas de computadores, configurar cada um destes
individualmente seria uma tarefa um tanto quanto complicada. Além disso, há a questão
dos provedores de acesso à Internet: os mesmos teriam de ensinar cada cliente a
configurar seus computadores e teriam de fornecer o endereço IP de cada cliente por
telefone e monitorar esses endereços, já que dois computadores não podem ter o mesmo
endereço IP [2].
De modo a facilitar esta configuração, existe um protocolo chamado DHCP
(Dynamic Host Configuration Protocol, Protocolo de Configuração Dinâmica de
Máquinas) que permite que computadores recebam suas configurações através de um
servidor DHCP. Esta é a configuração padrão para todos os computadores atualmente.
Quando se liga o computador, o mesmo pergunta ao servidor DHCP da rede (localizado
no provedor de acesso caso seja um usuário doméstico conectado à Internet) qual será o
endereço de IP e pronto, o computador está configurado. Caso tenha se montado uma
pequena rede com um roteador de banda larga, o roteador tem embutido um servidor
DHCP, sendo, portanto, o responsável por distribuir os endereços IP para os
computadores da sua rede [2].
Além do endereço IP, o servidor DHCP também envia outras informações de
configuração, como o endereço IP do servidor DNS que o computador deve usar, o
gateway padrão (o endereço IP do roteador da rede) e a máscara de sub-rede [2].
O DHCP é um protocolo da camada de aplicação e usa o protocolo UDP na
camada de transporte. O DHCP usa as portas 67 e 68 e na verdade o mesmo substitui
um protocolo antigo chamado BOOTP. Em algumas publicações se pode encontrar
referências ao BOOTP em vez do DHCP. Tudo o que foi dito sobre o DHCP é válido
24
para o BOOTP, já que o DHCP é 100% compatível com o BOOTP (apesar do DHCP
oferecer mais opções do que o BOOTP) [2].
DNS (Domain Name System)
O DNS (Domain Name System, Sistema de Nome de Domínio) permite o uso de
nomes como apelidos para os endereços IP. Por exemplo, é mais fácil memorizar o
nome de determinado site do que o endereço IP que o servidor web do mesmo está
usando [2].
Quando se digita no navegador o endereço do site (no caso, nome do site), o
protocolo DNS entra em ação, contatando um servidor DNS e perguntando qual
endereço IP está associado ao endereço digitado. O servidor DNS responderá o
endereço IP correspondente e então o navegador saberá qual endereço IP usar nesta
conexão [2].
O servidor DNS que o navegador usará é o servidor DNS que o computador está
configurado para usar – todos os computadores que estão conectados à Internet têm um
campo para configuração do endereço IP de pelo menos um servidor DNS.
Normalmente esta configuração é feita automaticamente via DHCP [2].
Se o servidor DNS não conhece o nome que foi digitado, o mesmo entrará em
contato com outro servidor DNS com um nível hierárquico maior de modo a aprender
este nome/endereço IP. Todas as entradas no servidor DNS têm um campo “tempo de
vida” (também chamado TTL, Time To Live), que diz ao servidor por quanto tempo
aquela informação é válida. Quando a informação vence, ela deve ser atualizada
contatando novamente o servidor DNS com um nível hierárquico maior. Isto é feito
desta forma porque caso o endereço IP de um servidor mude, o tempo máximo que se
precisará aguardar para aprender qual é o novo endereço IP para aquele servidor será o
campo TTL da entrada no servidor DNS - que pode variar de algumas horas a alguns
dias [2].
O DNS é um protocolo da camada de aplicação e suas requisições são feitas
usando a porta 53 do protocolo UDP na camada de transporte. Como já foi explicado, o
UDP não verifica se os pacotes chegaram ou não ao destino, mas, por outro lado, ele é
25
mais rápido, já que seu cabeçalho é menor e exige menos poder computacional para ser
processado [2].
O DNS permite que mais de um nome seja associado a um mesmo endereço IP.
Isto permite que se hospede mais de um site em um único servidor, por exemplo.
Quando se acessa um servidor que tem mais de um site hospedado, o navegador
acessará o mesmo através do endereço, enquanto que o servidor verificará o nome que
se está usando no navegador para saber qual site deve ser fornecido [2].
ICMP (Internet Control Message Protocol)
O ICMP (Internet Control Message Protocol, Protocol de Mensagens de
Controle Internet) é usado para enviar mensagens de controle para os roteadores. Este é
um protocolo da camada Internet e que funciona em conjunto com o protocolo IP. O
mesmo pode ser usado em várias situações em que pode ser necessário que um roteador
instruia outro sobre algo – normalmente quando um roteador recebe um datagrama que
não pode ser entregue, ele enviará de volta ao roteador que o enviou o datagrama uma
mensagem ICMP explicando o motivo pelo qual ele não pôde entregar o datagrama [2].
Algumas mensagens de controle que podem ser enviadas usando o ICMP são:
• Eco: Usada para testar se o caminho entre o receptor e o transmissor está bom. O
uso mais conhecido deste tipo de mensagem é através do comando Ping. Caso se
envie um comando Ping a um endereço de internet, por exemplo, o servidor do
mesmo responderá a essas solicitações de eco, e o Ping dirá se as mensagens
chegaram ou não ao servidor e qual foi o tempo gasto entre se enviar o comando
e a mensagem de eco voltar ao computador, normalmente dado em milisegundos
(ms) [2].
• Destino Inalcançável: Dentro desta mensagem o roteador pode dizer exatamente
o que ocorreu de errado, como rede inalcançável, computador inalcançável,
protocolo inalcançável, porta inalcançável, rede de destino inalcançável,
computador de destino inalcançável, se o administrador da rede bloqueou a rede
ou o computador de destino, problemas de roteamento, etc [2].
26
• Congestionamento: Esta mensagem é enviada caso o roteador esteja
sobrecarregado – isto é, caso ele esteja recebendo mais datagramas do é capaz de
processar – de modo a fazer com que o roteador que esteja enviando os
datagramas reduza a taxa de datagramas enviados para o roteador que está
sobrecarregado [2].
• Redirecionamento: Esta mensagem é normalmente usada quando um roteador
descobre que existe uma rota melhor para alcançar o destino, atualizando o
roteador transmissor. Este recurso apenas funciona em redes local, não
funcionando em redes grandes que tenham várias redes interconectadas, como a
Internet [2].
• Tempo de Vida Excedido: Todos os datagramas IP têm um campo tempo de
vida (TTL, Time To Live), que indica a quantidade de saltos (isto é, roteadores)
que o datagrama pode passar do computador transmissor até o computador
receptor. Se um datagrama está configurado com um TTL de 20, isto significa
que se ele não chegar ao destino dentro de 20 saltos, o datagrama deverá ser
descartado. Isto é feito para evitar que os datagramas fiquem eternamente
circulando na rede ou na Internet caso a rede não esteja configurada
corretamente e o datagrama esteja circulando sem qualquer caminho para
alcançar seu destino [2].
• Solicitação de Hora: Roteadores (e computadores) podem perguntar a hora a
outro roteador ou computador. Um dos usos desta mensagem é para sincronizar
os relógios dos dois computadores, apesar desta sincronização não ser perfeita,
já que existe um pequeno retardo introduzido pela rede (na ordem de
milisegundos). Esta mensagem pode ainda ser usada para medir o tempo de
retardo da rede entre dois computadores, se seus relógios estiverem
sincronizados [2].
Protocolos de Roteamento: RIP, OSPF e BGP
O roteamento pode ser estático ou dinâmico. Enquanto que em pequenas redes o
roteamento estático é usado – isto é, os datagramas sempre trafegam pelo mesmo
caminho para alcançarem o seu destino – na Internet ou em redes maiores o roteamento
dinâmico faz-se necessário [2].
27
Com o roteamento dinâmico, roteadores podem mudar as rotas a qualquer
momento, desde que eles percebam que existem melhores caminhos para alcançar um
determinado destino. Por exemplo, se existe mais de um caminho para alcançar um
dado destino e a rota atual é mais longa do que outra rota disponível, os roteadores
podem mudar a sua configuração para usarem a rota mais curta. Aqui “longa” e “curta”
referem-se ao número de saltos (isto é, roteadores) existentes no caminho. Rotas mais
curtas não são necessariamente mais rápidas [2].
A comunicação entre os roteadores de modo a reprogramarem as suas tabelas de
roteamento é feita usando um protocolo de roteamento. Os três protocolos de
roteamento dinâmico mais conhecidos são o RIP (Routing Information Protocol,
Protocolo de Informação de Roteamento), OSPF (Open Shortest Path First, Primeiro o
Caminho Mais Curto) e o BGP (Border Gateway Protocol, Protocolo de Gateway de
Fronteira) [2].
Se os roteadores estão usando o protocolo RIP, eles enviarão suas tabelas de
roteamento para todos os roteadores que eles têm acesso a cada 30 segundos. A tabela
de roteamento contém todas as redes que os roteadores conhecem e como alcançá-las,
além da distância (dada em número de saltos) até elas [2].
Quando cada roteador recebe uma nova tabela de roteamento de outro roteador,
ele pode ver se existe alguma rede nesta lista que tenha um caminho mais curto do que o
mesmo está atualmente configurado para usar. Se existir, o roteador se reconfigurará
para usar este novo caminho mais curto [2].
O problema é que os caminhos mais curtos nem sempre são os melhores, já que
o protocolo RIP não implementa nenhum modo para verificar o desempenho do
caminho. Ele também não verifica o congestionamento ou se o caminho é realmente
confiável. Portanto uma rota mais longa pode acabar sendo mais rápida. O RIP usa a
porta 520 do UDP [2].
Apesar do seu nome, o protocolo OSPF não procurar o caminho mais curto, mas
sim o caminho mais rápido. Quando os roteadores usam o protocolo OSPF, eles
verificam o estado dos outros roteadores que eles têm acesso de tempos em tempos
enviando mensagens chamadas “hello”. Através destas mensagens eles sabem se um
28
roteador está operacional e qual é o seu estado. Outra diferença é que usando o OSPF os
roteadores conhecem todos os caminhos que podem ser usados para alcançar um
determinado destino, enquanto que roteadores RIP conhecem apenas o caminho mais
curto. Uma terceira diferença é que roteadores baseados no RIP enviarão suas tabelas de
roteamento inteiras a cada 30 segundo, aumentando o tráfego da rede [2].
Outra diferença é que os roteadores baseados no OSPF permitem balanceamento
de carga: se existir mais de uma rota para um dado destino, o roteador pode dividir os
datagramas entre eles de modo a reduzir o tráfego em cada um dos caminhos. O OSPF
funciona diretamente na camada Internet com o protocolo IP, portanto ele não usa os
protocolos TCP ou o UDP [2].
O BGP é um protocolo usado em redes grandes, como a Internet – na verdade o
BGP é o protocolo usado pelos roteadores da Internet. Como tal, ele é classificado como
um protocolo externo, enquanto que o RIP e o OSPF são classificados como protocolos
internos – já que eles são usados em redes que estão sob a mesma administração [2].
O BGP agrupa roteadores e computadores sob uma mesma administração em
uma unidade chamada Sistema Autônomo (SA) – por exemplo, todos os roteadores e
computadores que pertencem ou estão conectados ao mesmo provedor de Internet fazem
parte de um mesmo SA. O BGP é chamado IBGP (Interno) se trabalha dentro de um
mesmo sistema autônomo ou de EBGP (Externo) se trabalha entre dois sistemas
autônomos diferentes [2].
O BGP é muito mais complexo do que o RIP e o OSPF, já que ele usa vários
critérios (chamados atributos) para determinar qual é a melhor rota a ser tomada: Peso,
Preferência Local, Discriminador de Saídas Múltiplas, Origem, Caminho SA, Próximo
Salto e Comunidade [2].
Ao contrário do RIP, os roteadores baseados no BGP enviam apenas o que há de
novo em suas tabelas de roteamento em vez de enviar a tabela inteira de tempos em
tempos, ajudando a diminuir o tráfego da rede. Uma diferença entre o BGP e o RIP é
que o BGP verifica de tempos em tempos se um dado caminho está acessível ou não. O
BGP utiliza a porta 179 do TCP [2].
29
ARP e RARP
O ARP (Address Resolution Protocol, Protocolo de Resolução de Endereço) é o
responsável por aprender qual é o endereço MAC (isto é, o endereço físico) de um
computador que tem um dado endereço IP e o RARP (Reverse Address Resolution
Protocol, Protocolo de Resolução de Endereço Reverso) faz o contrário: ele é o
responsável por descobrir qual é o endereço IP de um computador que tem um
determinado endereço MAC [2].
Enquanto um datagrama está sendo transmitido pela Internet, o endereço MAC
do computador de destino não é necessário – os roteadores no meio do caminho estão
interessados apenas em entregar o datagrama para a rede de destino. Mas, uma vez que
os pacotes chegam à rede de destino, o roteador conectado nessa rede precisa saber o
endereço MAC do computador de destino, já que ele irá entregar o datagrama
localmente (provavelmente usando o protocolo Ethernet) [2].
Por exemplo, se o endereço IP de destino é 69.69.69.69, quando o datagrama
chegar no roteador da rede 69.69.69.0, ele perguntará a todos os computadores (quando
uma mensagem é enviada para todos os computadores dizemos que ela é uma
mensagem de broadcast) usando o protocolo ARP: “Qual é o computador que tem o
endereço 69.69.69.69?” Em seguida o computador que tiver este endereço IP responderá
“sou eu!” [2].
Claro que enviar uma mensagem de broadcast toda hora congestiona a rede, e
por isso os roteadores mantêm uma tabela com os endereços IP conhecidos e seus
respectivos endereços MAC, dispensando assim que a mesma requisição seja feita caso
um novo datagrama destinado ao endereço 69.69.69.69 seja recebido [2].
O RARP, por outro lado, foi usado no passado pelos computadores sem mídia de
armazenamento para boot remoto. Como este tipo de computador não tem um sistema
operacional instalado, ele não sabe qual endereço IP usar. Ele precisa, portanto, saber
qual endereço IP usar de modo a iniciar a carga do sistema operacional do servidor de
boot remoto. Com se pode ver, este é exatamente o mesmo papel do DHCP e como
atualmente todas as redes usam um servidor DHCP, o uso do RARP tornou-se obsoleto.
Tanto o ARP e o RAR funcionam na camada de Interface com a Rede [2].
30
Outras Funcionalidades e Protocolos
Abaixo encontra-se uma lista de outras funcionalidade e protocolos relevantes
relacionados ao TCP/IP:
• NAT (Network Address Translation, Tradução de Endereço de Rede):
Teoricamente cada computador conectado à Internet precisa de um endereço IP
“público” válido. O NAT permite a uma rede local usar um único endereço IP
“público”. Por exemplo, quando conecta-se uma rede doméstica ou empresarial
à Internet usando um roteador de banda larga, o roteador usará o único endereço
IP “público” atribuído pelo provedor, enquanto que os computadores usarão os
endereços IP que são válidos apenas dentro da rede (chamados endereços IP
“mágicos”, normalmente na faixa 192.168.x.x). Do ponto de vista da Internet,
todos os computadores da rede estão usando o mesmo endereço IP. Portanto,
para enviar dados para um dos computadores da rede, o computador de origem
usará o endereço IP do roteador e quando este datagrama chegar ao roteador, ele
substituirá seu endereço IP pelo endereço IP que o computador de destino está
usando, que é válido apenas dentro da rede. Esta técnica é chamada NAT [2].
• IGMP (Internet Group Management Protocol, Protocolo de Gerenciamento de
Grupo Internet): A técnica de enviar o mesmo datagrama para todos os
computadores da rede é chamada broadcast, enquanto que a técnica de enviar o
mesmo datagrama para um determinado grupo de computadores (mas não todos)
é chamada multicast. O multicast no TCP/IP pode ser feito até mesmo se
computadores estiverem localizados em redes diferentes. Esses grupos são
gerenciados usando mensagens de controle IGMP. O IGMP usa o protocolo IP,
trabalhando na camada Internet [2].
• SNMP (Simple Network Management Protocol, Protocolo Simples de
Gerenciamento de Rede): Este protocolo é usado para monitorar os dispositivos
de hardware conectados a redes TCP/IP que o implementem. O SNMP é um
protocolo da camada de aplicação e usa as portas 161 e 162 do UDP [2].
31
• Finger: Este é um protocolo da camada de aplicação que usa a porta 79 do TCP
e é usado para descobrir informações sobre um dado usuário em um servidor.
Como ter acesso às informações pessoais de todos os usuários é realmente uma
má idéia, este serviço está quase sempre desabilitado [2].
Redes wireless
Introdução
Nos últimos anos as redes wireless caíram de preço e se tornaram extremamente
populares. Configurar uma rede wireless envolve mais passos do que uma rede cabeada
e um número muito maior de escolhas, incluindo o tipo de antenas e o sistema de
encriptação a utilizar, sem falar no grande volume de opções para otimizar a conexão
presentes na interface de administração do ponto de acesso [3].
O grande problema em utilizar cabos é que o custo do cabeamento cresce
exponencialmente junto com o número de clientes e a distância a cobrir. Montar uma
rede entre três ou quatro micros em um escritório acaba saindo barato, pois precisa-se
apenas de um switch e alguns metros de cabos. Mas cabear uma rede com 500 estações,
incluindo diversos andares de um prédio acaba sendo muito caro. Além disso, uma rede
cabeada oferece pouca flexibilidade. Caso se precise mudar alguns micros de lugar ou
adicionar novas estações à rede, será necessário alterar-se o cabeamento [3].
Existem ainda muitas situações onde simplesmente não é viável utilizar cabos,
como no caso de prédios antigos, onde não existem canaletas disponíveis e em situações
onde é necessário interligar pontos distantes, como dois escritórios situados em dois
prédios diferentes, onde você precisaria adquirir uma linha dedicada entre os dois
pontos, com a empresa de telefonia local (o que é caro) ou criar uma VPN, via internet
(o que resultaria em uma conexão lenta e com muita latência) [3].
Topologia básica
Em uma rede wireless, o hub é substituído pelo ponto de acesso (access-point
em inglês, comumente abreviado como "AP" ou "WAP", de wireless access point), que
tem a mesma função central que o hub desempenha nas redes com fios: retransmitir os
32
pacotes de dados, de forma que todos os micros da rede os recebam. A topologia é
semelhante à das redes de par trançado, com o hub central substituído pelo ponto de
acesso. A diferença no caso é que são usados transmissores e antenas em vez de cabos
[3].
Os pontos de acesso possuem uma saída para serem conectados em um
hub/switch tradicional, permitindo que se conecte os micros da rede com fios com os
que estão acessando através da rede wireless, formando uma única rede, o que é
justamente a configuração mais comum [3].
Existem poucas vantagens em utilizar uma rede wireless para interligar micros
desktops, que afinal não precisam sair do lugar. O mais comum é utilizar uma rede
cabeada normal para os desktops e utilizar uma rede wireless complementar para os
notebooks, palmtops e outros dispositivos móveis [3].
Utiliza-se um hub/switch tradicional para a parte cabeada, usando cabo também
para interligar o ponto de acesso à rede. O ponto de acesso serve apenas como a "última
milha", levando o sinal da rede até os micros com placas wireless. Eles podem acessar
os recursos da rede normalmente, acessar arquivos compartilhados, imprimir, acessar a
internet, etc. A única limitação fica sendo a velocidade mais baixa e o tempo de acesso
mais alto das redes wireless [3].
Isso é muito parecido com juntar uma rede de 10 megabits, que utiliza um hub
"burro" a uma rede de 100 megabits, que utiliza um switch. Os micros da rede de 10
megabits continuam se comunicando entre si a 10 megabits, e os de 100 continuam
trabalhando a 100 megabits, sem serem incomodados pelos vizinhos. Quando um dos
micros da rede de 10 precisa transmitir para um da rede de 100, a transmissão é feita a
10 megabits, respeitando a velocidade do mais lento [3].
Nesse caso, o ponto de acesso atua como uma ponte, transformando os dois
segmentos em uma única rede e permitindo que eles se comuniquem de forma
transparente. Toda a comunicação flui sem problemas, incluindo pacotes de broadcast
[3].
Para redes mais simples, onde se precisa apenas compartilhar o acesso à internet
entre poucos micros, todos com placas wireless, pode-se ligar o modem ADSL (ou
33
cabo) direto ao ponto de acesso. Alguns pontos de acesso trazem um switch de quatro
ou cinco portas embutido, permitindo que se crie uma pequena rede cabeada sem
precisar comprar um hub/switch adicional [3].
Figura 8 - Ligação de uma rede wireless a uma cabeada.
Com a miniaturização dos componentes e o lançamento de controladores que
incorporam cada vez mais funções, tornou-se comum o desenvolvimento de pontos de
acesso que incorporam funções adicionais. Tudo começou com modelos que
incorporavam um switch de quatro ou oito portas que foram logo seguidos por modelos
que incorporam modelos com funções de roteador, combinando o switch embutido com
uma porta WAN, usada para conectar o modem ADSL ou cabo, de onde vem a conexão.
Estes modelos são chamados de wireless routers (roteadores wireless) [3].
O ponto de acesso pode ser então configurado para compartilhar a conexão entre
os micros da rede (tanto os ligados nas portas do switch quanto os clientes wireless),
com direito a DHCP e outros serviços. Na maioria dos casos, estão disponíveis apenas
as funções mais básicas, mas muitos roteadores incorporam recursos de firewall, VPN e
controle de acesso [3].
Existem ainda roteadores wireless que incluem um modem ADSL, chamados de
"ADSL Wireless Routers". Basicamente, eles incluem os circuitos do modem ADSL e
do roteador wireless na mesma placa, e rodam um firmware que permite configurar
ambos os dispositivos. O link ADSL passa então a ser a interface WAN, que é
compartilhada com os clientes wireless e com os computadores ligados nas portas do
switch. Um dos conectores de rede no switch é então substituído pelo conector para a
linha de telefone [3].
34
Embora mais raros, encontram-se também roteadores com modems 3G
integrados (chamados de Cellular Routers ou 3G Routers), que permitem conectar via
EVDO (Vivo) ou UMTS/EDGE/GPRS (Claro, Tim e outras), usando um plano de
dados. O modem pode ser tanto integrado diretamente à placa principal quanto (mais
comum) instalado em um slot PC-Card. A segunda opção é mais interessante, pois
permite que se use qualquer placa [3].
Alguns modelos combinam o modem 3G e um modem ADSL, oferendo a opção
de usar a conexão 3G como um fallback para o ADSL, usando-a apenas quando o
ADSL perder a conexão. Esta combinação é interessante para empresas e para quem
depende da conexão para trabalhar, mas resulta em produtos mais caros, que nem
sempre são interessantes [3].
Continuando, além dos pontos de acesso "simples" e dos roteadores wireless,
existe ainda uma terceira categoria de dispositivos, os wireless bridges (pontes
wireless), que são versões simplificadas dos pontos de acesso, que permitem conectar
uma rede cabeada com vários micros a uma rede wireless já existente. A diferença
básica entre uma ponte e um ponto de acesso é que o ponto de acesso permite que
clientes wireless se conectem e ganhem acesso à rede cabeada ligada a ele, enquanto a
ponte faz o oposto, se conectando a um ponto de acesso já existente, como cliente [3].
A ponte é ligada ao switch da rede e é em seguida configurada como cliente do
ponto de acesso remoto através de uma interface web. Uma vez conectado às duas
redes, a ponte se encarrega de transmitir o tráfego de uma rede à outra, permitindo que
os computadores conectados às duas redes se comuniquem [3].
Usar um ponto de acesso de um lado e uma ponte do outro permite conectar
diretamente duas redes distantes, sobretudo em prédios diferentes ou em áreas ruais,
onde embora a distância seja relativamente grande, existe linha visada entre os dois
pontos. Como o trabalho de uma ponte é mais simples que o de um ponto de acesso,
muitos fabricantes aproveitam para incluir funções de ponte em seus pontos de acesso,
de forma a agregar valor [3].
35
Fisicamente, as pontes são muito parecidas com um ponto de acesso, já que os
componentes básicos são os mesmos. Em geral elas são um pouco mais baratas, mas
isso varia muito de acordo com o mercado a que são destinados [3].
Existe também a possibilidade de criar redes ad-hoc, onde dois ou mais micros
com placas wireless se comunicam diretamente, sem utilizar um ponto de acesso,
similar ao que temos ao conectar dois micros usando um cabo cross-over [3].
No modo ad-hoc a área de cobertura da rede é bem menor, já que a potência de
transmissão das placas e a sensibilidade das antenas são quase sempre menores que as
do ponto de acesso e existem outras limitações. Mas apesar disso as redes ad-hoc são
um opção interessante para criar redes temporárias, sobretudo quando se têm vários
notebooks em uma mesma sala [3].
Tipos de placas
Com relação às placas, é possível encontrar tanto placas PC Card, Express Mini
ou mini-PCI, para notebooks, quanto placas PCI e USB para micros desktop. Existem
inclusive placas ultra-compactas, que podem ser instaladas em um slot SD, destinadas a
palmtops [3].
Praticamente todos os notebooks à venda atualmente, muitos modelos de
palmtops e até mesmo smartphones incluem transmissores wireless integrados. Hoje em
dia, parece inconcebível comprar um notebook sem wireless [3].
Apesar disso, é bastante raro um notebook que venha com uma placa wireless
"onboard". Quase sempre é usada uma placa Mini-PCI (uma versão miniaturizada de
uma placa PCI tradicional, que usa um encaixe próprio) ou Express Mini (a versão
miniaturizada do PCI Express), que pode ser substituída, assim como qualquer outro
componente. Desde que não exista nenhuma trava ou incompatibilidade por parte do
BIOS, pode-se perfeitamente substituir a placa que veio pré-instalada [3].
Existem as placas wireless USB, que devido à praticidade e baixo custo estão se
tornando cada vez mais populares. O principal motivo é que elas são baratas e fáceis de
instalar (já que basta plugar na porta USB) e se pode utilizar a mesma placa wireless
tanto no desktop quanto no notebook [3].
36
Existem placas tanto com antena interna quanto externa. As com antena externa
são melhores, já que a antena oferece um maior ganho e pode-se ajustar a posição da
antena para obter a melhor recepção [3].
Alcance e interferência
As placas Wi-Fi também são placas Ethernet. As diferenças com relação às
placas cabeadas se restringem às camadas um e dois do modelo OSI, ou seja, na camada
física (representados pelos transmissores e antenas) e link de dados (a modulação do
sinal, encriptação via WPA ou WEP, correção de erros e outras funções executadas pelo
chipset placa). Do nível três em diante temos o TCP/IP e as demais camadas da rede,
que funcionam da mesma forma que em uma rede cabeada [3].
Com relação à transmissão dos dados, a principal diferença é que em uma rede
wireless o meio de transmissão (o ar) é compartilhado por todos os clientes conectados
ao ponto de acesso, como se todos estivessem ligados ao mesmo cabo coaxial. Isso
significa que apenas uma estação pode transmitir de cada vez, e que todas as estações
dentro da área de cobertura recebem todos os pacotes transmitidos da rede,
independentemente do destinatário. Isso faz com que a segurança dentro de uma rede
wireless seja uma questão sempre bem mais delicada que em uma rede cabeada [3].
O número máximo de clientes simultâneos suportados pelo ponto de acesso varia
de acordo com o fabricante e o firmware usado. Muitos pontos de acesso 802.11b
antigos eram limitados a 30 clientes, mas os atuais suportam um número maior. O
grande problema é que a banda disponível é compartilhada entre todos os clientes, de
forma que a velocidade prática da rede cai para níveis cada vez mais baixos conforme
novos clientes são conectados [3].
Uma solução para áreas onde é necessário atender a um grande número de
clientes é utilizar múltiplos pontos de acesso. Ao serem configurados com o mesmo
SSID, eles formam uma única rede, de forma que os clientes passam a automaticamente
se conectar ao ponto de acesso que oferecer o melhor sinal. Se o objetivo é melhorar a
taxa de transferência da rede, o ideal é conectar os pontos de acesso usando cabos de
rede e configurá-los para utilizar canais diferentes, de forma que eles possam realmente
transmitir simultaneamente, sem interferir entre si [3].
37
Em situações onde a prioridade é aumentar o alcance da rede, é possível também
utilizar repetidores wireless, que permitem estender o sinal do ponto de acesso principal,
sem que seja necessário puxar um cabo de rede até eles [3].
Outra característica das redes wireless é que o alcance da rede varia de forma
brutal de acordo com os obstáculos pelo caminho e com o tipo de antenas usadas, entre
outros fatores [3].
De uma forma geral, o alcance prometido pelos fabricantes para as redes
802.11b ou 802.11g são para ambientes fechados e para ambientes abertos o equivalente
a, respectivamente, 30 e 150 metros. Devido ao uso de mais transmissores e mais
antenas, o novo padrão 802.11n oferece um alcance um pouco maior, prometendo 70
metros em ambientes fechados e 250 metros em campo aberto. Entretanto, estes valores
são apenas médias estimadas, obtidos em testes padronizados [3].
As antenas usadas por padrão na maioria dos pontos de acesso, placas e
notebooks são antenas dipole com ganho de apenas 2 ou 2.2 dBi, mas existem no
mercado antenas com até 24 dBi. Existem ainda casos de antenas de uso restrito, que
podem superar a marca dos 30 dBi de ganho [3].
O "ganho" da antena diz respeito ao quanto ela consegue concentrar o sinal
transmitido. Quanto maior o ganho, mais concentrado é o sinal e maior a distância que
ele consegue percorrer. Para efeito de comparação, uma antena de 22 dBi transmite um
sinal 100 vezes mais concentrado do que uma antena de 2 dBi [3].
Em seguida tem-se a questão da potência dos transmissores usados nas placas e
nos pontos de acesso, que é medida em milliwatts. Um ponto de acesso típico utiliza um
transmissor de 56 milliwatts (17.5 dBm) ou de 63 milliwatts (18 dBm), mas o valor
varia de acordo com o modelo e o fabricante (alguns modelos chegam a oferecer 400
milliwatts) e o sinal pode ser amplificado para até 1 watt usando um amplificador
externo [3].
Usar uma antena de maior ganho tem um efeito similar a aumentar a potência de
transmissão do sinal e vice-versa. É justamente a combinação do uso de antenas de alto
ganho (em muitos casos combinadas com amplificadores) dos dois lados da conexão,
38
com um caminho livre de obstáculos, que permite a criação de links de longa distância
[3].
Por outro lado, em redes domésticas raramente usa-se amplificadores ou
substitui-se as antenas do ponto de acesso ou dos clientes, e é quase impossível oferecer
um caminho livre de obstáculos. Como o sinal wireless utiliza uma potência muito
baixa, qualquer obstáculo significativo causa uma grande perda [3].
As maiores inimigas do sinal são superfícies metálicas, como grades, janelas,
portas metálicas, lajes, vigas e até mesmo tintas com pigmentos metálicos. O metal
reflete a maior parte do sinal (propriedade que é explorada por muitas antenas),
deixando apenas uma pequena parte passar [3].
Em seguida temos materiais densos, como concreto e pedra. Paredes leves, feitas
com tijolo furado absorvem muito menos sinal do que paredes de construções antigas,
feitas com tijolos maciços, enquanto lajes ou vigas de concreto com armação metálica
absorvem mais do que ambas. O efeito é cumulativo, de forma que quanto mais paredes
pelo caminho, mais fraco é o sinal que chega do outro lado [3].
Outro obstáculo importante são corpos com grande concentração de líquido,
como aquários, piscinas, caixas d'água e até mesmo pessoas passeando pelo local. Ao
contrário dos metais, que refletem o sinal, a água o absorve, o que acaba tendo um
efeito ainda pior [3].
Além dos obstáculos, tem-se também focos de interferência, que competem com
o sinal do ponto de acesso, prejudicando a recepção por parte dos clientes, assim como
duas pessoas tentando falar ao mesmo tempo [3].
Fornos de microondas operam a 2.4 GHz, na mesma freqüência das redes
wireless, fazendo com que, quando ligados, eles se transformem em uma forte fonte de
interferência, prejudicando as transmissões em um raio de alguns metros. Um forno de
microondas é justamente um transmissor de rádio, de altíssima potência, que opera na
mesma faixa de freqüência das redes wireless, mas que serve para cozinhar alimentos ao
invés de transmitir dados. Caso se pudesse aumentar a potência de transmissão de uma
placa wireless em 10.000 vezes, teria um forno de microondas portátil [3].
39
Este é um dos motivos para a existência de normas que limitam a potência de
transmissão dos transmissores wireless domésticos a um máximo de um watt. No caso
do forno de microondas, é usada uma grade de metal para evitar que o sinal de rádio
escape. Ela é suficiente para evitar que ele cozinhe as pessoas em volta, mas uma
pequena porção do sinal, mais do que suficiente para interferir com as redes wireless
próximas, acaba escapando [3].
Telefones sem fio, além de transmissores bluetooth e outros aparelhos que
operam na faixa dos 2.4 GHz, também interferem, embora em menor grau. Os telefones
sem fio quase sempre utilizam o modo FH (Frequency Hopping), onde a freqüência de
transmissão varia em uma sequência pré-definida, em intervalos de apenas alguns
milisegundos. Com isso o telefone interfere com a rede em alguns momentos, quando as
frequências se cruzam (causando uma queda momentânea na taxa de transferência e
algumas retransmissões de pacotes), mas raramente o problema é crônico. De qualquer
forma, em escritórios e outros ambientes onde vários aparelhos de telefone sem fio
precisarem conviver com a rede wireless, é recomendável utilizar aparelhos que
trabalham na faixa dos 900 MHz [3].
Existe ainda a questão da interferência entre diferentes redes instaladas na
mesma área. Em um grande prédio comercial, com muitos escritórios de empresas
diferentes e cada uma com sua própria rede wireless, os pontos de acesso podem ser
configurados para utilizarem frequências diferentes, divididas em 14 canais. Na maioria
dos países, apenas 11 canais podem ser utilizados (devido à questão da legislação) e
destes, apenas três podem ser usados simultaneamente, sem perdas [3].
Ou seja, com várias redes instaladas próximas umas das outras, os canais
disponíveis são rapidamente saturados, fazendo com que o tráfego de uma efetivamente
reduza o desempenho da outra [3].
A combinação de todos esses fatores faz com que o alcance varie muito de
acordo com o ambiente. Você pode conseguir pegar o sinal de um ponto de acesso
instalado na janela de um prédio vizinho, distante 100 metros do seu (campo aberto),
mas não conseguir acessar a rede do andar de cima (a armação de ferro e cimento da
laje é um obstáculo difícil de transpor). Para compensar grandes distâncias, obstáculos
ou interferências, o ponto de acesso reduz a velocidade de transmissão da rede, como
40
um modem discado tentando se adaptar a uma linha ruidosa. Os 54 megabits do 802.11g
podem se transformar rapidamente em 11, 5.5, 2 ou até mesmo 1 megabit [3].
Uma última observação é que muitos pontos de acesso possuem problemas com
a temperatura. Nos dias muito quentes, o ponto de acesso superaquece e o calor
prejudica a recepção do sinal, reduzindo o alcance da rede, ou mesmo tirando-a do ar
completamente. Ao desligar o ponto de acesso da tomada e ligá-lo novamente pouco
depois, tudo volta a funcionar por certo tempo, até que ele superaqueça e o problema se
repita [3].
Padrões
O 802.11 é um conjunto de padrões criados pelo IEEE para o uso em redes
wireless. O padrão 802.11 original, hoje chamado de 802.11-1997 ou 802.11 legacy foi
publicado em 1997 e previa taxas de transmissão de um e dois megabits, usando a faixa
dos 2.4 GHz, escolhida por ser uma das poucas faixas de freqüência não licenciadas, de
uso livre [4].
Este padrão levou à criação de um pequeno número de produtos, apenas
parcialmente compatíveis entre si, mas lançou as bases para o desenvolvimento dos
padrões atuais. Estas primeiras placas 802.11 conviveram com placas baseadas em
padrões proprietários, incompatíveis entre sí, como o Arlan da Aironet e o WaveLAN,
da NCR, que trabalhavam na faixa dos 900 MHz e transmitiam a, respectivamente, 860
kbits e 2 megabits [4].
Além dos padrões do IEEE, temos também o Wi-Fi (Wireless Fidelity), uma
certificação (opcional) para produtos compatíveis com os padrões, que assegura que eles
sejam intercompatíveis [4].
Apenas os produtos certificados (um processo relativamente caro e demorado)
podem ostentar o logo "Wi-Fi Certified", de forma que muitos produtos, sobretudo os
produtos mais baratos não passam pela certificação e não são vendidos como produtos
Wi-Fi, embora isso não signifique necessariamente que eles sejam incompatíveis ou de
qualidade inferior [4].
41
Potência de transmissão e alcance
O alcance típico de uma rede 802.11g é de 30 metros em espaços fechados
(como uma casa ou um prédio, onde existem paredes e outros obstáculos) e 150 metros
em campo aberto, sem obstáculos. Entretanto, a distância máxima e a qualidade do sinal
(e, conseqüentemente, a velocidade de transmissão) podem variar bastante de um
modelo de ponto de acesso para outro, de acordo com a qualidade e potência do
transmissor e do ganho da antena usada pelo fabricante, sem contar os obstáculos
presentes entre o ponto de acesso e o cliente [5].
A potência total da transmissão é medida em dBm (decibel milliwatt), enquanto
o ganho da antena é medido em dBi (decibel isotrópico). Em ambos os casos, é usado o
decibel como unidade de medida, mas o parâmetro de comparação é diferente, daí o uso
de duas siglas distintas [5].
No caso da potência de transmissão, o parâmetro de comparação é um sinal de
um milliwatt. Dentro da escala, um sinal de um milliwatt corresponde a 0 dBm. A partir
daí, cada vez que é dobrada a potência do sinal, são somados aproximadamente 3
decibéis, já que, dentro da escala, um aumento de 3 decibéis corresponde a um sinal
duas vezes mais forte, da mesma forma que temos com o som [5]:
Tabela 1 - relação de decibéis com miliwatts
0 dBm 1 miliwatt
3 dBm 2 miliwatts
6 dBm 4 miliwatts
9 dBm 7.9 miliwatts
12 dBm 15.8 miliwatts
15 dBm 31.6 miliwatts
18 dBm 61.1 miliwatts
21 dBm 125.9 miliwatts
24 dBm 251.2 miliwatts
27 dBm 501.2 miliwatts
30 dBm 1000 miliwatts
60 dBm 1000000 miliwatts
O ganho da antena, por sua vez, é medido em relação a um radiador isotrópico,
um modelo teórico de antena, onde o sinal seria transmitido igualmente em todas as
42
direções. Um radiador isotrópico seria uma esfera perfeita, sem diferença alguma de
polarização em toda a superfície. Ele é impossível de construir na prática (já que a
presença do conector já tornaria a esfera imperfeita) e não seria muito útil de qualquer
forma, pois mandaria muito sinal para o céu e para a terra e menos sinal para os clientes
que devem recebê-lo [5].
Todas as antenas concentram o sinal em determinadas direções, sendo que
quanto mais concentrado é o sinal, maior é o ganho. Uma antena de três dBi, por
exemplo, irradia o sinal com o dobro de potência que um radiador isotrópico, porém
irradia em um ângulo duas vezes menor. Uma antena de seis dBi oferece um sinal
quatro vezes mais concentrado, porém para um ângulo 4 vezes mais estreito, e assim por
diante. De uma forma geral, quanto maior é o ganho desejado, maior precisa ser a
antena; justamente por isso as antenas ominidirecionais e yagi de alto ganho são muito
maiores que as antenas padrão de 2.2 dBi dos pontos de acesso [5].
Calculando a potência
A potência total de saída é obtida convertendo a potência do transmissor, de
milliwatts para dBm e, em seguida, somando o ganho da antena (em dBi). A maioria
dos modelos domésticos de pontos de acesso trabalham com 17.5 dBm (56 milliwatts)
ou 18 dBm (63 milliwatts) de potência, mas existem modelos com apenas 15 dBm (31.6
milliwatts) e, no outro extremo, alguns modelos com até 400 milliwatts (26 dBm) [5].
É importante notar que, em muitos casos, a potência anunciada pelo fabricante
inclui o ganho da antena, de forma que um ponto de acesso com sinal de 20 dBm pode
ser, na verdade, um ponto de acesso com transmissor de 18 dBm e uma antena de 2 dBi.
Nesse caso, obter-se-iam 24 dBm ao substituir a antena padrão por uma antena de 6 dBi
e não 26 dBm (20+6) como poderia-se pensar à primeira vista. Uma diferença de dois
dBm pode parecer pequena, mas na verdade equivale a um aumento de 66% na potência
do sinal, daí a importância de verificar as especificações com atenção [5].
A lógica é simples. Nenhuma antena irradia o sinal igualmente em todas as
direções. Mesmo as antenas ominidirecionais irradiam mais sinal na horizontal que na
vertical. Isso significa que o sinal é concentrado dentro da área de transmissão da
antena, tornando-se mais forte. Como vimos, quanto maior o ganho da antena, mais
43
concentrado e forte é o sinal, fazendo com que ele seja capaz de percorrer distâncias
maiores e superar mais obstáculos. Se a potência de transmissão nominal é de 400 mW,
o uso de uma antena de 2.2 dBi faria com que, na prática, se tivesse uma potência de
transmissão de 880 mW (29.4 dBm) [5].
Se a antena padrão fosse substituída por uma antena yagi com ganho de 18 dBi,
a potência de transmissão subiria para 44 dBm e, se a antena tivesse 24 dBi, subiria para
impressionantes 50 dBm. Na prática, os valores seriam um pouco mais baixos, devido à
perda introduzida pelo cabo e pelos conectores, mas ainda assim os números seriam
impressionantes [5].
Mesmo um ponto de acesso mais simples, com um transmissor de 56 milliwatts
(17.5 dBm), pode atingir uma boa potência de transmissão se combinado com uma
antena de bom ganho. Mesmo usando uma antena setorial de 12 dBi, a potência total de
transmissão já seria de 29.5 dBm, o que equivale a 891 milliwatts. A principal diferença
é que nesse caso o sinal seria concentrado em uma área muito menor, tornando-o
utilizável para um link de longa distância, mas não para uma rede doméstica, onde o
sinal precisa ficar disponível em todo o ambiente [5].
Em se tratando de links de longa distância, é preciso ter em mente que a potência
de transmissão do ponto de acesso não está necessariamente relacionada à sua
sensibilidade de recepção, e a falha em captar o sinal do cliente também leva à perda da
conexão. Ou seja, para obter um ganho tangível, é necessário usar produtos com uma
maior potência de transmissão dos dois lados do link [5].
Uma antena de alto ganho (corretamente focalizada), por outro lado, aumenta
tanto a potência de transmissão quanto a sensibilidade de recepção, já que é capaz de
concentrar o sinal em ambas as direções. É por isso que instalar uma antena yagi na
placa do seu notebook permite que ele consiga se conectar a redes tão distantes, mesmo
sem modificações nos respectivos pontos de acesso [5].
44
Calculando a distância
O sinal transmitido pelo ponto de acesso é espalhado por uma grande área, de
forma que apenas uma pequena quantidade da energia irradiada seja efetivamente
captada pela antena receptora. Abaixo tem-se a perda teórica em um ambiente livre de
obstáculos [5]:
Tabela 2 - Relação de perda em decibéis por distância
500 m -94.4 dB
1 km -100.4 dB
2 km -106.4 dB
4 km -112.4 dB
Estes números são puramente teóricos, a começar pelo fato de que não temos
(pelo menos não dentro da atmosfera do nosso planeta) um ambiente completamente
livre de obstáculos, já que a própria umidade do ar atenua o sinal em certa intensidade
[5].
Em um ambiente real, poder-se-ia calcular uma perda de 117 dB para uma
distância de 2 km em campo aberto, com um acréscimo de 6 a 9 dB cada vez que a
distância dobra [5].
A margem é necessária, pois em uma situação real raramente consegue-se obter
um alinhamento perfeito das antenas e fatores ambientais, como o vento e a chuva, que
podem balançá-las (tirando-as da posição ideal). Além disso, variações da umidade
afetam o sinal, de forma que o mesmo é mais atenuado em dias chuvosos, o que é um
dos grandes problemas dos provedores que oferecem acesso wireless. Sem uma boa
margem de tolerância, a rede poderá funcionar bem nos dias de tempo bom, mas ficar
instável nos dias nublados ou durante as chuvas [5].
Subtraindo a perda da potência inicial do sinal, obtém-se o valor que chega até o
cliente. Se a potência inicial (incluindo o ganho da antena) é de 19 dBm e a perda
causada pelo percurso (incluindo os obstáculos) é de 117 dB, por exemplo, significa que
o cliente receberá um sinal de apenas -98 dBm. Se a potência de transmissão fosse
aumentada para 26 dBm, ele receberia -91 dBm e assim por diante [5].
45
Apresentam-se valores negativos, que consistem em apenas uma pequena fração
de milliwatt. Como foi visto, um sinal de 1 milliwatt equivale a 0 dBm e precisa-se
dobrar a potência do sinal para cada 3 dBm adicionais. Da mesma forma, cada vez que
divide-se a potência do sinal pela metade, subtrai-se 3 dBm, de forma que -3 dBm
equivalem a 0.5 milliwatt, -6 dBm correspondem a 0.25 e assim por diante [5].
Ao receber o sinal, o cliente precisa amplificá-lo, de forma que ele possa ser
processado. Entra em cena então outra especificação importante, que é a sensibilidade
de recepção (receive sensitivity), que corresponde ao nível mínimo de sinal que o cliente
precisa para receber os dados, com um volume aceitável de erros de recepção [5].
Ao criar um link de longa distância, é importante usar pontos de acesso e placas
com a maior sensibilidade possível. Uma diferença de apenas 6 dB na recepção permite
obter o dobro do alcance, utilizando as mesmas antenas. Este acaba sendo o principal
diferencial entre placas de diferentes fabricantes, mesmo quando elas são baseadas no
mesmo chipset [5].
Os aparelhos baseados no 802.11n oferecem uma taxa de transferência muito
maior a curtas distâncias, devido ao uso do MIMO, mas esta característica é
praticamente inútil em links de longa distância, onde normalmente utilizamos uma
única antena. O 802.11n oferece algumas melhorias adicionais no sistema de correção
de erros e na transmissão do sinal, que reduzem o overhead da transmissão em relação
ao 802.11g, resultando em certo ganho na taxa de transmissão (mesmo com uma única
antena) [5].
A maioria dos dispositivos trabalha com um valor mínimo de -92 dBm e alguns
chegam a -95 dBm (nota-se que a sensibilidade de recepção não está necessariamente
relacionada à potência de transmissão). Entretanto, esse valor corresponde à taxa de
transmissão mínima, a um megabit. Para que a rede possa trabalhar a velocidades mais
altas, é necessário um sinal mais forte. Abaixo apresentam-se os valores referentes para
diferentes taxas de transmissão [5].
Tabela 3 - valores de referência para taxas de transmissão
1 mbps -92 dBm
2 mbps -91 dBm
46
5.5 mbps -90 dBm
9 mbps -88 dBm
12 mbps -87 dBm
18 mbps -86 dBm
24 mbps -83 dBm
36 mbps -80 dBm
48 mbps -74 dBm
54 mbps -72 dBm
Pela Tabela 3 pode-se ver que um sinal de -98 dBm é muito baixo, mesmo para
criar um link de apenas 1 megabit. Para cada redução de 3 dB no sinal, tem-se uma
redução de 50% na potência, de forma que -98 dBi correspondem a apenas um quarto de
-92 dBi, que seria o mínimo para estabelecer a conexão, dentro das especificações da
tabela [5].
Uma simples antena setorial ou yagi com 8 dBi de ganho, devidamente apontada
para a antena do ponto de acesso remoto, seria suficiente para elevar o sinal ao nível
mínimo (a 1 megabit), mas seria necessário usar uma antena com pelo menos 26 dBi
para ter uma chance de efetuar a conexão na velocidade máxima, a 54 megabits [5].
Uma antena de 26 dBi de ganho seria muito cara e volumosa, e a instalação seria
difícil, já que tanto ganho resulta em um sinal muito focalizado. Nesse caso, seria muito
mais simples usar uma antena de maior ganho no ponto de acesso, mantendo o cliente
com uma antena de 8 ou 12 dBi [5].
A fórmula para calcular o sinal que chega efetivamente ao receptor é:
Potência de transmissão + ganho da antena - perda de sinal + ganho da antena
receptora
Usando repetidores
A forma mais simples de aumentar o alcance da rede wireless é utilizar diversos
pontos de acesso configurados com o mesmo SSID para cobrir uma área maior. Os
pontos de acesso são então ligados a um switch central (ou a um conjunto de switches)
utilizando cabos de rede. Os clientes enxergam, então, uma única rede em qualquer
47
ponto da área de cobertura e, ao se conectarem à rede, simplesmente se conectam ao
Acess Point (AP) mais próximo [5].
Em áreas onde não seja possível puxar um cabo de rede, é possível usar um
computador com duas placas de rede (uma wireless e outra cabeada), configurado para
se conectar a um dos pontos de acesso existentes usando a placa wireless e rotear os
pacotes para outro ponto de acesso, ligado na placa cabeada [5]:
Figura 9 - Exemplificação de uma rede wireless.
Usando cabos de par trançado é possível atingir distâncias de apenas 100 metros,
mas é possível usar cabos de fibra óptica nos segmentos em que for necessário cobrir
distâncias maiores. Usar cabos é a forma de interligação entre os pontos de acesso que
oferece o melhor desempenho e melhor estabilidade, mas naturalmente não é a mais
prática [5].
É possível também aumentar o alcance da rede utilizando repetidores (também
chamados de "expanders", ou expansores). Eles são aparelhos autônomos que atuam
como intermediários entre o ponto de acesso principal e os clientes, retransmitindo o
sinal. A idéia é que eles sejam usados para melhorar a cobertura em pontos cegos da
rede, reforçando o sinal que chega até os clientes, ou para superar obstáculos
(posicionar o repetidor em uma posição em que ele tenha linha visada com o AP
48
principal e também com o cliente permite que o sinal "faça a curva", evitando o
obstáculo) [5].
Em casos em que a distância seja muito grande, ou não exista linha visada entre
o ponto de acesso principal e o repetidor, é possível usar um repetidor intermediário
(relay) para permitir que o sinal chegue até ele. Na ilustração abaixo, por exemplo, tem-
se um exemplo de configuração, onde dois pontos de acesso (um deles configurado
como repetidor) são usados para permitir que um notebook situado em outro prédio
tenha acesso à rede [5]:
Figura 10 - Exemplo de uso de repetidores em redes wireless.
No diagrama da Figura 10 os prédios aparecem lado a lado, mas em uma
situação real eles poderiam estar a 2 km ou mais de distância um do outro, desde que
fossem usadas as antenas apropriadas e que tanto o repetidor quanto o ponto de acesso
remoto fossem posicionados nas janelas ou em outra posição onde existisse linha visada
entre eles. O ponto de acesso local fica posicionado no interior do prédio, em uma
posição onde exista uma boa comunicação entre ele, os clientes locais e o repetidor [5].
Uma vez configurados, os repetidores precisam ser apenas ligados à rede elétrica
para fazerem silenciosamente seu trabalho. É possível também utilizar uma placa solar,
combinada com uma bateria e um inversor para obter um repetidor completamente
autônomo [5].
Apesar de a idéia parecer simples, o uso de repetidores wireless tornou
necessária a criação de um novo protocolo, o WDS (Wireless Distribution System) para
permitir o encaminhamento de frames Ethernet entre os pontos de acesso e os
49
repetidores. É possível inclusive usar dois pontos de acesso compatíveis com o WDS,
configurando um como mestre e outro como repetidor, não sendo necessário usar um
dispositivo especializado [5].
O maior problema é que o WDS ainda não faz parte do padrão Wi-Fi nem é
ratificado pelo IEEE, o que abre margem para diferenças de implementação entre os
diversos fabricantes e o lançamento de produtos incompatíveis [5].
Especificações do Sistema
Para o desenvolvimento do projeto, alguns requisitos são especificados. O
computador a ser usado para controle do veículo deve ter a configuração mínima tal
qual descrito abaixo:
• Processador: 2,06 GHz;
• Memória: 256 Mb;
• Placa de vídeo: 64 Mb;
• Sistema operacional: Windows 2000, Windows XP, Windows Vista ou
Windows 7.
Já os componentes do veículo apresentam as seguintes configurações básicas:
• Alcance da rede wireless: máximo de 150 metros em campo aberto e de 30
metros em ambientes com paredes;
• Autonomia: variável. Dependente da qualidade das pilhas e baterias usadas;
• Movimentação angular horizontal da câmera: 360º;
• Movimentação angular vertical da câmera: 90º;
• Resolução das imagens enviadas pela câmera: 640 x 480 ou 320 x 240;
• Suporte para envio e recebimento de áudio pela câmera;
• Suporte para gravação de imagens enviadas pela câmera;
• Tempo de resposta do sinal enviado pelo computador e recebido pela placa:
menor que um segundo;
• Peso estimado do veículo: 4 kg.
Ainda, no que diz respeito à comunicação, foram usados os protocolos HTTP na
camada de aplicação do protocolo TCP/IP, TCP na camada de transporte e IP na
camada de internet.
50
O diagrama de blocos a seguir exemplifica a forma com que os dispositivos se
comunicam.
Figura 11 - Diagrama de blocos do sistema desenvolvido
O computador, através de um roteador se comunica com a câmera
TCP/IP e com o Access Point. Este último comunica-se com a placa Renesas. A placa,
por sua vez, comunica-se com o carro, fazendo com que o mesmo movimente-se.
Desenvolvimento
Componentes utilizados e seus custos
Para o desenvolvimento e montagem do processo foram necessários vários
componentes. A grande maioria dos componentes foi adquirida. Abaixo segue uma
listagem dos mesmos bem como os respectivos preços.
• Carro de controle remoto modelo Rock Crawler, fabricante Maisto Tech – R$
149,00;
• Câmera TCP/IP wireless – R$ 300,00;
• Placa RX62N do kit demonstrativo, fabricante Renesas – Cedida gratuitamente
pela empresa;
• Access Point modelo TL – WA701ND, fabricante TP-Link – R$ 165,00.
• Carro plástico de brinquedo, modelo Truck caçamba, fabricante Nillo – R$
29,00.
• Controle de XBOX 360 com conexão para computador, fabricante Microsoft –
R$ 180,00.
• Demais componentes (baterias, conectores, 7805, capacitores, placa de
montagem de circuito, parafusos, porcas, etc.) – menos que R$ 50,00.
51
Instalação e programação da câmera Após a escolha e aquisição da câmera a ser usada no projeto, iniciou-se a
instalação da mesma. O Erro! Fonte de referência não encontrada. apresenta, passo a
passo, como deve-se proceder para que a instalação seja feita corretamente.
Esta câmera é comumente utilizada como equipamento de segurança e
monitoramento. Devido a isto, a mesma apresenta uma série de funções que podem ser
utilizadas, como envio de e-mail caso note movimento, utilização de várias câmeras no
mesmo software entre outros. Porém, para o propósito do projeto, esses recursos não
foram necessários. A câmera foi utilizada apenas com suas funções básicas, de envio de
imagens via TCP/IP.
Após a instalação, pode-se usar o aplicativo “IP Camera Finder”, encontrado no
cd de instalação e que deve ser instalado, para encontrar a câmera. Após clicar duas
vezes no ícone (que estará no desktop), a seguinte tela aparecerá:
Figura 12 - janela de interface do IP Camera Finder.
Deve-se clicar em “Wizard Mode” e em seguida em “next”. Com isso, chegar-
se-á na tela abaixo:
52
Figura 13 - Tela de localização das câmeras.
Então, aparece a configuração da câmera. Ao dar duplo clique na referência da
câmera (em azul na imagem), aparecerá seguinte tela:
Figura 14 - Tela com dados de endereço da câmera.
Então, deve-se clicar em “open” (ao lado da seta). Dessa forma,
automaticamente será aberta uma página no navegador padrão do computador. Nesta
página, será pedido um login e uma senha. O padrão para login é “Admin” e a senha
permanece em branco. Após inserirem-se estes dados, clica-se em “ok”. Então, a
seguinte página será exibida:
53
Figura 15 - página de seleção de navegador do programa de utilização da câmera.
Deve-se então escolher a opção que indica o navegador usado. A primeira opção
é para Internet Explorer, a segunda para demais navegadores e a terceira é para uso em
celulares.
Após isso, será aberta a página de utilização da câmera, como mostra a Figura
16 a seguir:
Figura 16 - página inicial do programa da câmera.
54
Percebe-se que a câmera já está em uso. Porém, caso seja desejada a mudança de
alguma configuração, deve-se clicar no ícone no canto inferior esquerdo (circulado em
vermelho). Com isso, aparecerá uma nova tela, conforme Figura 17 a seguir:
Figura 17 - página de configurações da câmera,
Nesta tela, encontra-se à esquerda uma série de opções de configuração. De
forma geral, as configurações já encontram-se na forma que serão utilizadas para o
projeto.
Em alguns roteadores, a porta 80 de rede já é usada internamente. Como a porta
padrão da câmera também é esta, caso tenham-se conflitos, deve-se mudar a porta. Para
isso, deve-se escolher a opção “Basic Network Settings” no menu da esquerda. Nesta
opção, deve-se alterar o campo “Http port” para outro valor que não seja 80, e de
preferência um valor entre 81 e 85. Após a escolha, deve-se clicar em “submit” para que
a alteração seja salva. A Figura 18 a seguir mostra a página descrita acima:
55
Figura 18 - tela de alteração da porta usada pela câmera.
Ainda, caso a roteador onde a câmera esteja se conectando seja protegido por
senha, deve-se configurar a câmera para que a mesma possa acessar este roteador. Para
isso, clica-se na opção “Wireless Lan Settings” no menu de opções. A seguinte tela
aparecerá:
Figura 19 - Tela para configuração de senha para câmera.
Então, deve-se clicar em “Scan” para que o programa busque as redes sem fio.
Caso existam mais de uma rede ao alcance da câmera, escolhe-se a rede desejada (no
caso, a rede em azul). Ainda, deve-se colocar no campo “Share Key” a mesma senha
usada pelo roteador. Após isso, deve-se clicar em “Submit” para que as alterações sejam
salvas.
Após essas configurações terem sido feitas, a câmera encontrar-se-á em
condições de uso. Então, para acessar a pagina de controle da câmera, será necessário
apenas que se abra uma página no navegador do computador e digite-se o IP referente à
câmera. Ainda, caso a porta tenha sido alterada, deve-se especificar a mesma. Neste
56
caso, com as configurações mostradas na Figura 18, é necessário que digite-se no
navegador o seguinte IP: “http://192.168.1.100:81/”. Desta forma, não é necessário que
se use o programa “IP Camera Finder”, uma vez que as configurações já foram salvas.
Mapeamento e utilização dos sinais do carro
Após a escolha do carro de controle remoto a ser usado no projeto, foi necessário
que se mapeasse a forma com que os sinais são usados para que os motores sejam
acionados. Essa necessidade deu-se pelo fato de que no manual do carro não existe
nenhuma informação quanto ao funcionamento do circuito integrado. Para isso,
desmontou-se a estrutura do carro a fim de se chegar ao circuito encontrado no mesmo.
Ainda, no circuito apenas encontram-se nomenclaturas referentes aos componentes
usados, mas não referentes ao seu funcionamento.
Utilizando-se de um multímetro para verificar as variações de tensão no circuito,
emitiram-se sinais através do controle e então verificou-se de que forma esses sinais
eram interpretados. Para cada sinal dado pelo controle (frente, trás, direita e esquerda)
percebeu-se que ocorriam variações em pontos diferentes da placa. Então, notou-se que
os sinais eram recebidos e usados para acionar os transistores usados nas pontes H que
fazem com que os motores girem ou em sentido horário ou anti-horário. Percebeu-se
ainda que cada vez que o controle era acionado para realizar determinada função, o
circuito interno recebia um sinal de três volts no ponto referente a esta função.
Pode-se determinar então que o ponto R21 recebe o sinal que indica que o carro
deve virar as rodas para a direita, o ponto R22 recebe o sinal para virar à esquerda, o
ponto Q4 usa o sinal para andar para frente e o ponto Q5 recebe o sinal para andar para
trás. Também foi mapeado o ponto onde encontra-se o aterramento do circuito. Tais
pontos são demonstrados na Figura 20 a seguir:
57
Figura 20 - placa do circuito integrado do carro de controle remoto.
Então, foram soldados fios nestes cinco pontos para que posteriormente fosse
feita a ligação com a placa de comando.
A fim de garantir que os comandos eram realmente recebidos nestes pontos,
utilizaram-se duas pilhas modelo AA de 1,5 volts em série, garantindo-se assim três
volts, para alimentar cada ponto e verificar se os mesmos acionariam os motores. Como
esperado, ao acionarem-se estes pontos, o veículo movimentou-se para frente, trás
direita e esquerda.
Instalação e configuração da placa Para que os comandos fossem enviados pelo computador e pudessem
movimentar o carro, foi utilizada uma placa de circuitos integrados que fez esta
interligação. A placa escolhida para tal foi a de modelo RX62N, do fornecedor Renesas.
Para que a placa possa ser devidamente instalada, deve-se entrar no site da
empresa, indicado na embalagem de placa (www.renesas.com/RDKRX62Ninstall) e
fazer o download do software e da documentação para o kit. Deve-se então fazer o
download da opção “Download installation CD for RX62N RDK” como mostra a
Figura 21 a seguir (indicado em vermelho):
58
Figura 21 - página de download do cd para a placa do kit.
Então, será feito o download do arquivo, de aproximadamente 600 Mb,
correspondente ao cd de instalação da placa.
Após encerrado o download, devem-se extrair os arquivos (os mesmos vem
“zipados”) para a pasta desejada. Dentro da pasta extraída, deve-se clicar no ícone
“autorun”, e então será aberto o programa de instalação, conforme Figura 22 a seguir:
Figura 22 - Tela inicial do programa de instalação da placa do kit Renesas.
Selecionam-se então as quatro opções e em seguida clica-se em “next”. Então,
devem-se seguir os passos da instalação, clicando-se sempre em “next”, para que os
59
programas sejam instalados. Ainda, sempre que for solicitado que cadastros sejam
feitos, é necessário que os façam, pois para o correto funcionamento do kit, todos os
cadastros devem estar efetuados. Ainda, todos estes cadastros são gratuitos, bem como a
utilização dos serviços oferecidos para o kit.
Uma vez que todos os cadastros foram efetuados e a instalação foi concluída, os
programas estarão disponíveis para uso. Pode-se notar que no desktop e no “menu
iniciar” estarão disponíveis os novos programas.
Antes de iniciar-se a utilização do programa, a placa deve ser conectada ao
computador. Para tal, deve-se usar cabo USB, conectado ao computador e à placa. A
ligação da placa deve ser feita através do plug J-14, como mostram a Figura 23 e a
Figura 24 abaixo:
Figura 23 - Foto da placa do kit Renesas.
Figura 24 - Esquemático da placa do kit Renesas.
60
Pode-se notar que, ao conectar a placa ao computador, o display LCD e alguns
leds acendem.
Através do “menu iniciar”, deve-se entrar no programa “High-performance
Embedded Workshop” (Menu iniciar/Todos os programas/Renesas/ High-performance
Embedded Workshop/ High-performance Embedded Workshop). Este é o software
utilizado para fazer a programação do kit e a transferência dos arquivos para a placa.
Ainda, o software conta com cinco programas exemplos utilizados para facilitar
a interação do usuário com a placa. Como o projeto busca a comunicação via TCP/IP,
utilizou-se o exemplo cinco, que é dedicado a este tipo de utilização para a placa. Ainda,
no Anexo 1 pode-se encontrar o manual do usuário da placa, com todas as informações
relevantes, bem como a explicação de cada exemplo.
Assim que o programa for iniciado, uma tela de boas-vindas (welcome) será
apresentada, conforme Figura 25 abaixo:
Figura 25 - Tela de boas vindas do programa HEW.
Nesta tela, deve-se escolher a terceira opção (Browse to another Project
workspace) e em seguida clicar em “OK”. Então, será aberta uma tela para a escolha do
projeto desejado. Deve-se buscar o projeto que encontra-se no endereço
C:\Micrium\Software\EvalBoards\Renesas\YRDKRX62N\GNURX, e clicar em
“select”, como mostra a Figura 26 a seguir:
61
Figura 26 - Escolha do projeto a ser aberto pelo programa.
Neste projeto encontram-se os exemplos vindos no cd de instalação. Com base
neles que os novos programas foram desenvolvidos.
Então, uma nova janela aparecerá, a fim de determinar o kit que está sendo
usado. Deve-se certificar que no campo “MCU group” encontra-se “RX62N Group” e
que no campo “device” encontra-se “R5F562N8”. Ainda, deve-se escolher a opção
“Debugging Mode”. Após isso, deve-se clicar em “Ok”, como mostra a Figura 27 a
seguir:
Figura 27 - Seleção do kit correto pelo programa HEW.
Após isso, uma nova janela aparecerá, denominada “Configuration Properties”.
Deve-se clicar em “Ok”.
Nota-se que o programa foi inicializado. Então, deve-se certificar que as opções
“debug” e “J-Link” foram selecionadas no topo da tela. Ainda, com o botão direito do
62
mouse clique sobre “uCOS-III-ex5” na lateral esquerda da tela e em seguida em “set as
current project”, como mostra a Figura 28 abaixo:
Figura 28 - Configurações básicas e escolha do exemplo 5.
Desta forma, o exemplo 5 será carregado. Pode-se notar então que abaixo de
“uCOS-III-ex5” existem uma série de arquivos. Estes arquivos são os programas em
linguagem C++ que são usados para fazer a interligação do computador com a placa. É
baseado neles que será feita a programação conforme desejado. Na realidade, apenas o
arquivo “app_http.c” será modificado no programa desejado. Os demais arquivos serão
mantidos.
Este exemplo 5 faz uma interligação entre a placa e o computador através de
uma página HTML que fica armazenada na memória interna da placa. A página original
do exemplo está representada na Figura 29 abaixo:
Figura 29 - página original do exemplo 5 do kit Renesas.
63
Porém, para a utilização do projeto proposto, deseja-se utilizar uma página
diferente. Com isso, editou-se a pagina para que a mesma fosse utilizada com os
propósitos desejados. Para tal foram feitas alterações na programação HTML da página.
Ainda, no Anexo 3 encontram-se informações sobre programação em linguagem
HTML.
Para que a programação seja mudada, deve-se clicar com o botão direito do
mouse sobre o ícone “index” que se encontra no endereço
C:\Micrium\Software\EvalBoards\Renesas\YRDKRX62N\GNURX\uCOS-III-
Ex5\Webpages e escolher a opção “abrir com/bloco de notas”.
Então, alterou-se a programação de forma a se obter a nova página. As
programações antiga e nova em HTML encontram-se no Anexo 4. Após isso, a nova
página ficou conforme a Figura 30 abaixo:
Figura 30 - Nova página a ser usada no programa do carro.
Cada botão da página acima representa uma função de comando para o carro. A
Tabela 4 a seguir indica qual a função de cada botão.
Tabela 4 - Função e código dos botões da página HTML.
Botão Função Access key
Q Movimentar o carro para frente e para esquerda Q
W Movimentar o carro para frente W
E Movimentar o carro para frente e para direita E
A Movimentar o carro para trás e para esquerda A
S Movimentar o trás para frente S
D Movimentar o carro para trás e para direita D
64
Ainda, nota-se que no comando do controle remoto um botão faz mover para
frente e outro para a direita, por exemplo. Se ambos forem apertados ao mesmo tempo,
faz com que o carro mova-se para frente e para a direita. Porém, a placa apenas aceita
programação em HTML, e este tipo de programação é muito simples. Desta forma, a
página não consegue interpretar dois botões apertados ao mesmo tempo. Por este
motivo foram criados seis botões, sendo que cada um deve ser apartado
individualmente, fazendo com que o carro possa mover-se em todas as direções.
Além disso, a linguagem HTML permite que se use um comando chamado
“Access key” para que as ações possam ser feitas pelo teclado. Para tal, devem-se
apartar simultaneamente as teclas “shift”, “alt” e a respectiva tecla de acesso de cada
botão, que estão representados na Tabela 4 acima. Por exemplo, para mover o carro para
frente, deve-se apartar o botão 2, ou as teclas “shift”, “alt” e “w”.
Porém, o software da placa reconhece a programação feita em linguagem C++.
Para isso, usa-se o programa Bin2C_win, que faz a conversão dos arquivos em HTML
para C++. O programa pode ser encontrado para download gratuitamente na internet.
Após o download, deve-se instalar o programa. Posteriormente, deve-se dar
duplo clique no ícone “BIN2C_WIN” que encontra-se na pasta onde o programa foi
instalado. Então será aberta uma janela, conforme Figura 31 - Tela inicial do programa
Bin2C_WinFigura 31 abaixo:
Figura 31 - Tela inicial do programa Bin2C_Win
Deve-se então clicar em “add” e buscar o arquivo “index.html” na pasta
C:\Micrium\Software\EvalBoards\Renesas\YRDKRX62N\GNURX\uCOS-III-
Ex5\Webpages. Este é o arquivo referente à nova página que foi criada. Após isso,
deve-se clicar em “save”. Então, uma nova janela será aberta, para que escolha-se o
65
endereço de destino do arquivo. Deve-se escolher o mesmo endereço descrito acima,
onde encontra-se o arquivo “index.html”. Ainda, o arquivo deve ser salvo com o nome
“webpages”. Ao clicar em “ok” será aberta uma janela. Então, deve-se clicar em “sim”
para substituir o arquivo já existente pelo novo arquivo. Desta forma, a página HTML
foi substituída pela nova página e a programação em linguagem C++ referente à página
também está alterada, para que possa ser interpretado pelo software.
Agora, novamente no programa “High-performance Embedded Workshop”
deve-se fazer as alterações na programação em linguagem C++ para que os comandos
possam ser enviados. Escolhe-se então o arquivo “app_http.c” conforme descrito
anteriormente. Ao dar-se duplo clique no arquivo, o mesmo será aberto na região central
da tela, com toda a programação contida no mesmo.
Com base na programação original, algumas alterações foram feitas para que o
programa funcione conforme deseja-se. Abaixo serão explicadas as alterações. A
programação completa encontra-se no Anexo 5.
A primeira alteração acontece em relação à quantidade de botões e funções do
programa. No modelo original, apenas dois botões são usados. Já no novo programa,
são seis botões. Para isso, alterou-se a programação referente à “local defines” de:
#define HTTPs_VAL_REQ_BUF_LEN 20u
#define HTML_LED_INPUT_NAME "LED"
#define HTML_LED1_TOGGLE_INPUT_VALUE "LED1"
#define HTML_LED2_TOGGLE_INPUT_VALUE "LED2"
#define LED1 15u
#define LED2 4u
Para:
#define HTTPs_VAL_REQ_BUF_LEN 20u
#define HTML_LED_INPUT_NAME "LED"
#define HTML_LED1_TOGGLE_INPUT_VALUE "LED1"
#define HTML_LED2_TOGGLE_INPUT_VALUE "LED2"
#define HTML_LED3_TOGGLE_INPUT_VALUE "LED3"
#define HTML_LED4_TOGGLE_INPUT_VALUE "LED4"
#define HTML_LED5_TOGGLE_INPUT_VALUE "LED5"
#define HTML_LED6_TOGGLE_INPUT_VALUE "LED6"
#define LED1 13u
#define LED2 14u
#define LED3 15u
#define LED4 4u
#define LED5 5u
66
#define LED6 6u
Deve-se notar que as inscrições “LED1”, “LED2” até “LED6” são a forma de
fazer a interpretação dos sinais que serão enviados pela página HTML. Na programação
HTML, apresentada no Anexo 4, os botões tem seus valores como “LED1”, “LED2” até
“LED6”. Além disso, cada valor de “LED” é associado a um led real encontrado na
placa, com, por exemplo, “LED1” está associado ao led 13 encontrado na placa. Isso é
feito pois cada led real está associado a uma saída de sinal encontrada na parte inferior
da placa, como mostra a Figura 32 a seguir:
Figura 32 - Indicação dos leds na placa Renesas.
Posteriormente as ligações externas serão explicadas. Por hora, serão explicadas
as alterações na programação.
Agora, na parte referente a “HTTPs_ValRx()” foram feitas algumas alterações.
A primeira delas acontece na inserção do comando “LED_On(0)”. Este comando faz
com que todos os leds sejam acesos. Isso é feito para que nas saídas interligadas aos
leds tenham-se sinais de 0 volts. É importante que se ressalte que quando o led está
aceso a saída tem sinal de 0 volts e quando o led está apagado a saída tem sinal de três
volts.
int i=0;
CPU_BOOLEAN HTTPs_ValRx (CPU_CHAR *p_var,
CPU_CHAR *p_val)
{
CPU_INT16U cmp_str;
67
CPU_BOOLEAN ret_val;
LED_On(0);
ret_val = DEF_FAIL;
Além disso, foram feitas alterações nas programações referentes aos valores de
LED1 e LED2, além de serem inseridas programações para LED3, LED4, LED5 e
LED6. No programa original, apenas dois botões estavam disponíveis, e relacionavam-
se com LED1 e LED2. No programa novo têm-se seis botões.
Na programação original, cada vez que um botão era apertado, o led real
associado a este botão mudava de estado. Se estivesse ligado, era desligado, se estivesse
desligado, era ligado. No novo programa, cada vez que um botão é apertado, faz com
que o(s) led(s) relacionado(s) seja(m) apagado(s) por certo tempo. Isso acontece porque
a linguagem HTML é básica e não consegue manter um botão apertado constantemente.
Cada vez que um botão é apertado, a página é recarregada. Com isso, o led permanece
apagado por um tempo, suficiente para que a página seja recarregada. Após este tempo,
os leds são novamente ligados, evitando assim que o sinal seja enviado
ininterruptamente.
Ainda, os leds estão relacionados ao movimento desejado no carro. O led 15
indica movimentação pra frente, o led 6 significa mover para trás, led 4 indica direita e
o led 14 indica esquerda. Com isso, as programações de LED1 a LED6, que estão
associados aos botões da página HTML, acionam os leds reais de acordo com o
movimento proposto. Essa associação é apresentada na Tabela 5 abaixo:
Tabela 5 - Relação dos movimentos do veículo com os leds reais da placa.
LED Função Led real
1 Movimentar o carro para frente e para esquerda 15 e 14
2 Movimentar o carro para frente 15
3 Movimentar o carro para frente e para direita 15 e 4
4 Movimentar o carro para trás e para esquerda 6 e 14
5 Movimentar o trás para frente 6
6 Movimentar o carro para trás e para direita 6 e 4
Dessa forma, a programação é:
cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 1. */
(CPU_CHAR *)HTML_LED1_TOGGLE_INPUT_VALUE);
68
if (cmp_str == 0) {
LED_Off(14);
LED_Off(15);
for (i=0;i<2000000;i++)
{}
LED_On(14);
LED_On(15);
ret_val = DEF_OK;
}
cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 2. */
(CPU_CHAR *)HTML_LED2_TOGGLE_INPUT_VALUE);
if (cmp_str == 0) {
LED_Off(15);
for (i=0;i<2000000;i++)
{}
LED_On(15);
ret_val = DEF_OK;
}
cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 3. */
(CPU_CHAR *)HTML_LED3_TOGGLE_INPUT_VALUE);
if (cmp_str == 0) {
LED_Off(15);
LED_Off(4);
for (i=0;i<2000000;i++)
{}
LED_On(15);
LED_On(4);
ret_val = DEF_OK;
}
cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 4. */
(CPU_CHAR *)HTML_LED4_TOGGLE_INPUT_VALUE);
if (cmp_str == 0) {
LED_Off(6);
LED_Off(14);
for (i=0;i<2000000;i++)
{}
LED_On(6);
LED_On(14);
ret_val = DEF_OK;
}
cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 5. */
(CPU_CHAR *)HTML_LED5_TOGGLE_INPUT_VALUE);
if (cmp_str == 0) {
LED_Off(6);
for (i=0;i<2000000;i++)
{}
LED_On(6);
ret_val = DEF_OK;
}
69
cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 6. */
(CPU_CHAR *)HTML_LED6_TOGGLE_INPUT_VALUE);
if (cmp_str == 0) {
LED_Off(6);
LED_Off(4);
for (i=0;i<2000000;i++)
{}
LED_On(6);
LED_On(4);
ret_val = DEF_OK;
}
}
Após a programação alterada, deve-se apertar o botão “Build All” na parte
superior da tela. Isso é feito para que o programa seja compilado e verificada a
existência ou não de erros. Então, deve-se apertar o botão “Reset Go” para que o
programa seja carregado e possa ser executado. A Figura 33 abaixo mostra a posição
dos botões.
Figura 33 - Localização dos botões Build All e Reset Go.
Em seguida, o programa deve ser transferido para a memória interna da placa,
para que possa ser executado sem que a placa esteja conectada ao computador. Para que
isso seja feito, deve-se desconectar o programa da placa, apertando-se o botão
“Disconnect”, como mostra a Figura 34 a seguir:
70
Figura 34 - Localização dos botões Connect e Disconnect.
Posteriormente, deve-se apertar o botão “connect”. Novamente, uma janela será
aberta. Nela, deve-se escolher a opção “Writing the on-chip flash memory mode” e em
seguida deve-se clicar em “ok”, conforme Figura 35 abaixo:
Figura 35 - Modificações para gravação de programa na memória.
Posteriormente, devem-se confirmar positivamente as janelas que aparecerão e o
programa será salvo na memória interna da placa.
Para que o programa seja acessado, deve-se conectar a placa a uma fonte de
energia, através do conector J4 e também deve-se conectar através da entrada ethernet
um cabo de rede. Este cabo é conectado ao roteador. A Figura 36 abaixo mostra a
posição onde os cabos devem ser conectados.
71
Figura 36 - Conectores de alimentação e de rede da placa.
Após isso, aparecerá no visor do display LCD o número de IP referente à placa.
Deve-se então abrir o navegador e digitar este IP, como por exemplo,
http://192.168.1.92. Com isso, a página HTML que foi criada e salva na memória da
placa será aberta no navegador. Esta página já estará relacionada à placa. Caso os botões
sejam acionados na placa, suas respectivas ações serão recebidas e executadas na placa.
Ainda, para que os sinais obtidos através dos comandos com os leds reais
pudessem se conectar ao circuito integrado do carro e assim movimentá-lo, foi
necessário que se utilizasse a interligação dos leds com os pontos de sinais de saída,
como já dito anteriormente. Para que se saiba qual pino de saída está relacionado a cada
led, deve-se ver os esquemáticos da placa, apresentados no Anexo 6. A Figura 37
abaixo mostra as partes relevantes do esquemático para possa se determinar a saída
relacionada a cada led real.
72
Figura 37 - Conexões dos leds da placa Renesas.
Os quatro leds que são usados na programação são 4, 6, 14 e 15. Portanto,
apenas serão apresentados os pontos para estes leds.
Percebe-se que o led 14 está ligado ao BLED1, que por sua vez está conectado,
através de uma resistência ao sinal LED1. Este sinal por sua vez é conectado ao pino 13
das saídas de sinal. Nota-se que para os leds 4, 6 e 15 têm-se os pinos 18, 15 e 19,
respectivamente. Ainda, o pino 4 representa o pino de aterramento. Então, nestes pinos
foram soldados os fios para fazer a interligação com o circuito integrado do carro.
Como dito anteriormente, os pinos do circuito integrado tiveram os fios soldados
para a interligação. Portanto, fez-se a ligação dos fios saídos da placa com os fios saídos
do carro. O fio do pino 19 da placa foi conectado ao fio responsável por mover o carro
para frente. O fio do pino 15 foi conectado ao fio responsável por mover o carro para
trás. Pino 18 conectado ao fio de movimentação para direita e pino 13 conectado ao
movimento pra esquerda. Ainda, o fio do pino 4 foi conectado ao fio de aterramento do
carro, a fim de garantir que ambos os circuitos encontrem-se sob mesmo “terra”.
Instalação e configuração do Access Point O sistema de comunicação TCP/IP da placa Renesas dá-se pela utilização de um
cabo serial com um roteador. Porém, para que o carro tenha total mobilidade, o mesmo
precisa encontra-se livre de cabos que o conectem a sistemas fixos. Para isso, foi
necessário que se conectasse à entrada ethernet da placa um aparelho que a
73
transformasse em wireless. Este aparelho é conhecido como Access Point, porém foi
configurado para a função cliente. Esta função faz com que um sinal de entrada de cabo
de rede seja convertido em sinal wireless.
Para que o aparelho seja configurado, primeiramente deve-se conectá-lo. Para
isso, deve-se conectar a fonte de alimentação na sua respectiva entrada. Ainda, deve-se
conectar o cabo de rede no aparelho e no roteador.
Após isso, deve-se abrir um navegador e digitar o IP 192.168.1.254. Feito isso,
será pedido um “user name” e um “password”. Em ambos os campos deve-se digitar
“admin”. Feito isso, deve-se clicar em “ok”. Então, será aberta a página de
configuração, como mostra a Figura 38 a seguir:
Figura 38 - página inicial de configuração do Access Point.
Então, deve-se escolher a opção “wireless” no menu lateral. Em seguida, deve-se
escolher a opção “wireless settings”. Feito isso, deve-se escolher a opção “client” em
“operation mode”. Em seguida, deve-se clicar em “search”, e então uma lista com as
redes wireless ao alcance do aparelho será mostrada. Escolhe-se então a rede desejada.
Em seguida, clica-se em “save”, como mostra a Figura 39 a seguir:
74
Figura 39 - Configuração no modo cliente e escolha da rede.
Ainda, caso o roteador seja protegido por senha, deve-se configurar o Access
Point para que possa acessar a rede. Para isso, ainda no menu “wireless”, deve-se
escolher a opção “wireless security”. Então, deve-se escolher o tipo de codificação
usado pelo roteador, por exemplo, WAP, e em seguida digitar a senha. A senha deve ser
exatamente a mesma usada no roteador. Feito isso, deve-se clicar em “save”, como
mostra a Figura 40 abaixo:
Figura 40 - Configuração de senha do Access Point.
75
Após isto, o aparelho já está configurado e pronto para ser usado. Então,
conecta-se um cabo de rede da saída ethernet da placa Renesas à entrada ethernet do
Access Point. Uma vez que a placa e o aparelho estejam alimentados, automaticamente
será feita a conexão da placa com o roteador. Desta maneira, obtém-se um sistema que
se comunica com a rede através de sinal wireless, não dependendo assim da conexão de
cabos para transmissão de dados.
Alimentação do sistema Para que o carro seja totalmente desprovido da conexão por cabos, é preciso que
a câmera, a placa Renesas e o Access Point possuam fontes de alimentação móveis. Para
isso, foram montados sistemas com baterias que fornecessem as cargas necessárias para
cada dispositivo. Ainda, para que os motores do veículo funcionem ao ser acionados, o
mesmo precisa estar conectado a seis pilhas modelo AA de 1,5 Volts cada.
O Access Point usa fonte de alimentação de 9 Volts. Para que o mesmo funcione
sem estar conectado a uma tomada, foi conectada uma bateria 9 Volts convencional a
um conector e então ligado à entrada da fonte do aparelho. Com isso, o mesmo passou a
funcionar normalmente sem a presença de cabos. As Figura 41 e Figura 42 abaixo
mostram a bateria e o conector utilizados para essa conexão.
Figura 41 - Bateria de 9V convencional.
Figura 42 - Conector para dispositivos usados no carro.
A placa Renesas e a câmera funcionam usando fontes de 5 Volts cada. Então,
utilizou-se uma bateria para fornecimento de tensão para ambas. Porém, a bateria
utilizada é uma bateria de 6 Volts. Para atingir a tensão desejada, foi utilizado um
circuito com um regulador de tensão 7805 (o datasheet do mesmo encontra-se no Anexo
7) e dois capacitores, de 23 e 100 nF, que funcionam como filtros para os sinais. A
76
bateria utilizada e uma demonstração do circuito utilizado estão representadas nas
Figura 43 e Figura 44 a seguir:
Figura 43 - Bateria de 6V usada no circuito.
Figura 44 - Representação do circuito regulador de tensão.
Então, o sinal negativo da bateria é conectado ao terra do circuito. O sinal
positivo é conectado à entrada do 7805, obtendo-se assim a saída do 7805 com 5 Volts.
Esta saída é ligada a conectores como o da Figura 42 para que possa ser interligado aos
equipamentos.
Ainda, o circuito com o 7805 e os capacitores foi montado sobre uma placa de
montagem de circuitos de 10 x 10 centímetros.
Montagem do veículo Para o acoplamento dos componentes foi necessária a utilização de um chassi de
apoio para o carro, uma vez que a estrutura do veículo era insuficiente para que todos os
dispositivos fossem postos sobre o mesmo. Para tal, utilizou-se de um carro de plástico
no formato de caçamba. As peças que encontravam-se sobre o carro foram retiradas.
Ainda, na parte frontal do veículo foram feitos dois furos. Por esses furos foram
colocados dois parafusos. Este chassi de apoio pode ser visto na Figura 45 a seguir:
77
Figura 45 - Chassi de apoio.
Estes parafusos foram usados para conectar o chassi de apoio ao veículo
motorizado. Neste último também foram feitos dois furos, para que as partes pudessem
ser presas. A Figura 46 abaixo mostra a ligação entre as mesmas.
Figura 46 - Conexão entre os dois chassis.
Sobre o chassi de apoio foram colocados o Access Point, a placa Renesas e as
baterias. Já sobre o carro controlado foi colocada a câmera, que foi presa por um
parafuso para não cair. Desta forma, o veículo ficou conforme mostram as Figura 47 e
Figura 48 a seguir:
78
Figura 47 - Vista lateral do veículo montado.
Figura 48 - Vista superior do veículo montado.
Utilização de Joystick Além de comandar o veículo pelo mouse, ao se apertar os botões na tela, e do
teclado, através das teclas de acesso, foi criado também um método de controle através
de joystick. Para tal, foi usado o programa Xpadder, que pode ser encontrado pra
download gratuito pela internet. Este programa é usado para que os controles do joystick
possam ser programados para executar qualquer comando, seja por mouse ou por
teclado. Isso é necessário para que os comandos usados para acionar os botões da
página de controle por teclado possam ser acionados através do controle.
Ainda, o controle que foi usado é um controle de videogame XBOX 360, como
mostra a Figura 49 abaixo:
Figura 49 - Controle de XBOX 360.
79
Uma vez que o controle está conectado ao computador, deve-se fazer a
configuração do programa. Para isso, deve-se abrir a pasta onde o programa está e dar
duplo clique no ícone “Xpadder”. Com isso uma janela do programa é aberta. O
Xpadder reconhece automaticamente o controle conectado ao computador. Tem-se
então a janela inicial representada na Figura 50 a seguir:
Figura 50 - Tela inicial do programa Xpadder.
Agora, para que os botões sejam programados, basta que se clique sobre o botão
desejado. Ao clicar-se em um botão, uma nova janela é aberta, como mostra a Figura 51
a seguir:
Figura 51 - Tela para escolha de função.
Esta janela representa o teclado do computador e o mouse (este na parte direita
da janela). Então, deve-se clicar na tecla que deseja ser representada pelo botão do
controle. Ainda, pode-se usar o botão do controle para representar mais de uma tecla
80
pressionada ao mesmo tempo. Para isso, basta que se clique nas teclas desejadas, como
por exemplo, “ctrl”, “alt” e “F”.
A Figura 52 a seguir mostra os botões que foram programados:
Figura 52 - Botões programados para o projeto do carro.
Com base nos números apresentados na Figura 52 acima, a Tabela 6 a seguir
apresenta a função adotada a cada botão programado:
Tabela 6 - Relação de botões e respectivas funções.
Botão Função
1 Teclas shift + alt + W
2 Teclas shift + alt + Q
3 Teclas shift + alt + E
4 Teclas shift + alt + S
5 Teclas shift + alt + A
6 Teclas shift + alt + D
7 Tecla Enter
8 Tecla F5
9 Movimento do mouse para frente
10 Movimento do mouse para trás
11 Movimento do mouse para esquerda
12 Movimento do mouse para direita
13 Botão esquerdo do mouse
14 Botão direito do mouse
15 Botão central do mouse
81
Ainda, os botões do controle foram programados de acordo com as funções
relevantes para o controle do veículo. A tecla F5 faz parte destas funções, pois
representa a função “recarregar” no Windows. Como a programação em HTML é muito
instável, por vezes a página não é carregada corretamente. Para isso, utiliza-se este
comando para que a página seja novamente carregada e possa voltar a funcionar
normalmente.
Resultados
Após a passagem por todas as etapas, obteve-se como resultado um veículo
capaz de exercer as ações propostas. Porém, pode-se notar que inúmeros problemas
foram encontrados até que se chegasse ao resultado final.
Dentre os problemas, pode-se citar a dificuldade em encontrar sistemas que não
sejam computadores que façam comunicações ethernet, principalmente wireless. A
solução encontrada foi a utilização de uma placa pronta da Renesas. Ainda sobre os
problemas, a programação em HTML é extremamente limitada, impossibilitando a
criação de sistemas mais completos. Além disso, é um sistema com certa instabilidade,
não sendo totalmente confiável.
A dimensão dos componentes também pode ser caracterizada como um
problema ao projeto. Como a placa, a câmera e o Access Point são relativamente
grandes, foi necessário que se criasse um segundo chassi de apoio, apenas para o
carregamento de componentes, fazendo com que o veículo ficasse maior e mais pesado.
Outra dificuldade encontrada dá-se pelo fato de baterias mais potentes serem
difíceis no mercado, muitas vezes sendo encontradas apenas com voltagens diferentes
das desejadas e por preços elevados.
Ainda, para a programação e execução do projeto foi usado um computador com
as seguintes configurações:
• Processador: 2,06 GHz;
• Memória: 2,93 Gb;
• Placa de vídeo: 256 Mb;
• Sistema operacional: Windows XP.
82
Com o sistema descrito acima, o computador suportou bem todos os recursos do
veículo. Percebe-se que a máquina atinge todos os requisitos básicos necessários para o
funcionamento correto.
Já para os testes realizados com o veículo pronto, conseguiram-se os seguintes
resultados:
• Rede wireless: testes realizados em campo com obstáculos foram feitos
em distâncias de até 10 metros. Não foram realizados testes em campo
aberto, pela dificuldade de encontrar-se ambientes totalmente
desprovidos de paredes, torres, carros, muros etc;
• Com as baterias usadas, conseguiu-se uma autonomia de
aproximadamente 15 minutos. Após isso, alguns recursos começaram a
apresentar dificuldades ou falhas no funcionamento;
• Movimentação angular horizontal da câmera: 360º;
• Movimentação angular vertical da câmera: 90º;
• Envio e recebimento de áudio pela câmera em funcionamento, porém a
qualidade do som é baixa, assim como o volume;
• Gravações de imagens enviadas pela câmera foram feitas com sucesso;
• Tempo de resposta do sinal enviado pelo computador e recebido pela
placa: menor que um segundo em funcionamento normal. Porém, em
momentos onde a página precisou ser recarregada, este tempo superou
uma unidade em segundos.
Percebe-se que, com base nos resultados apresentados, a maioria dos recursos
apresentou funcionamento satisfatório se comparados aos requisitos iniciais. Ainda, não
foi possível testar-se o alcance total da rede wireless. Porém, com os valores testados, os
resultados atingiram as expectativas. Além disso, o tempo de resposta apresentou
oscilações devido à instabilidade da página HTML. Em condições normais de uso, o
mesmo atingiu os requisitos iniciais, porém, em momentos de instabilidade, os
resultados obtidos estiveram fora das especificações. Ainda, quanto à autonomia, a
bateria de 9 volts usada para alimentar o access point foi a responsável pela interrupção
do funcionamento do veículo. Embora as outras baterias tenham permanecido em boas
condições e alimentando o sistema, esta encerrou sua capacidade de fornecimento e
impediu que o sistema permanecesse em uso.
83
Conclusão
Com base nos estudos realizados, pode-se perceber que a comunicação TCP/IP
permite que sejam criados circuitos para variados propósitos, e não apenas a interação
entre computadores. Desta forma, este recurso pode e deve ser mais explorado para
novos recursos. Ainda, a comunicação wireless traz uma gama enorme de possibilidades
de projetos que podem ser elaborados visando possibilitar a mobilidade dos
equipamentos de forma fácil e prática.
Mais do que isso, a elaboração do projeto permitiu concluir-se que é possível
criar um veículo controlado remotamente de forma relativamente simplificada e com
baixos custos se comparados aos valores de projetos de empresas especializadas.
Em relação às condições técnicas, é possível concluir-se que a geração de fontes
de alimentação por baterias e pilhas é possível, porém apresentam limitações de
corrente e de autonomia. Alguns circuitos necessitam de potências altas, e com isso
consomem a carga das fontes geradoras rapidamente. Ainda, a baixa gama de recursos
oferecidos pela linguagem HTML limita a qualidade e estabilidade da comunicação
entre o computador e o veículo.
Também pode-se concluir que a utilização de recursos wireless enviados pelo
veículo e recebidos por roteadores é útil, porém obriga que, para que o veículo possa ser
utilizado, roteadores e redes wireless estão ao alcance das antenas mesmo. Problema
este que limita os campos de utilização do sistema projetado.
Tendo por base as dificuldades encontradas neste projeto, pode-se levantar uma
série de possibilidades de melhorias que podem ser exploradas em projetos futuros. A
seguir, listam-se alguns desses pontos.
• Redução de dimensões de componentes, para que se tenha um veículo menor e
mais leve;
• Programação em linguagem mais completa e segura do que HTML, por
exemplo, Java;
• Utilização de baterias solares para alimentação do sistema, de forma a aumentar
a autonomia do veículo em campos abertos;
• Utilização de tecnologia 3G para recebimento e emissão de sinais pelo veículo,
eliminando assim a necessidade de contato com redes wireless e roteadores.
84
Anexo 1
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
Anexo 2
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
Anexo 3
Introdução à linguagem HTML Este anexo tem por objetivo fazer uma breve introdução à linguagem HTML,
apresentando os conceitos e comandos básicos. Todas as informações contidas no
mesmo foram obtidas no site http://cdcc.sc.usp.br/tutorial/index.htm.
Um documento HTML (HyperText Markup Language) é um conjunto de
instruções em formato ASCII, usada para criar documentos hipertexto e que podem ser
visualizados por um navegador (como o Internet Explorer).
Para criar uma página HTML pode-se usar qualquer editor que possa salvar
arquivos no formato "ASCII com quebras de linhas", como por exemplo, o Notepad do
Windows, ou então usar um editor HTML específico.
A linguagem HTML utiliza Tags (marcações) que informam ao browser como
exibir o documento. As marcações do HTML consistem do sinal < (o símbolo de
"menor que") seguida pelo nome da marcação e fechada por > ("maior que"). De um
modo geral, as tags aparecem em pares, por exemplo, <H1> Cabeçalho</H1>. O
símbolo que termina uma determinada marcação é igual aquele que a inicia, antecedido
por uma barra (/). No exemplo, <H1> inicia a formatação do primeiro nível de
cabeçalho e </H1> indica que o cabeçalho acabou.
Há excessões a esse funcionamento em pares das marcações. Por exemplo, a que
indica um final de parágrafo, <P>, não necessita de um Tag correspondente </P>. A
marcação que indica quebra de linha, <BR>, também não precisa de uma
correspondente, e outras tais como <HR> e <LI>. Ainda, HTML não faz diferença entre
maiúsculas e minúsculas. Então, a notação <title> é equivalente a <TITLE> ou
<TiTlE>.
Todo documento deve conter um conjunto básico de Tags. Deve ser identificado
como HTML (<HTML> </HTML>), ter uma área de cabeçalho (<HEAD> </HEAD>)
onde será colocado o título do documento (<TITLE> </TITLE>), e uma área definida
169
como corpo (<BODY> </BODY>) onde estará o conteúdo do documento. Veja um
exemplo:
<HTML> <HEAD> <TITLE>HTML Básico</TITLE> </HEAD> <BODY> <H1>Este é o primeiro nível de cabeçalho</H1> Bem-vindo ao mundo do HTML. Este é o primeiro parágrafo.<P> E este é o segundo.<P> </BODY> </HTML>
Esta página vai aparecer assim: O título não aparece no corpo da página e sim no alto da tela do seu navegador, e
é utilizado para identificar o documento como se fosse um nome do arquivo. É
interessante que o título possa sugerir claramente o conteúdo do documento.
A marcação utilizada para títulos é <TITLE> e seu par </TITLE>. Escrito desta forma:
<HTML> <TITLE> Este é o título</TITLE> <BODY> </BODY> </HTML>
Cabeçalhos normalmente são usados para títulos e subtítulos dentro de uma
página.
O HTML possui seis níveis de cabeçalhos, numerados de 1 a 6, sendo o número 1 o de
maior destaque. Cabeçalhos são exibidos em letras maiores e em negrito. Ainda, ao
definir o tamanho de um cabeçalho, não se está definindo o tamanho da letra (em
pontos), apenas define-se que ele aparecerá com maior tamanho e destaque que o resto
do texto. O tamanho exato com que ele será visualizado é definido pelo navegador de
cada pessoa que acessar a informação.
Este é o primeiro nível de cabeçalho
Bem-vindo ao mundo do HTML. Este é o primeiro parágrafo.
E este é o segundo.
170
As notações relativas a cabeçalhos são: <Hy> Texto do cabeçalho </Hy>
onde y é um número entre 1 e 6 especificando o nível do cabeçalho. O conjunto de
notações possíveis é o que segue:
<H1>Headings</H1>
<H2>Headings>/H2>
<H3>Headings</H3>
<H4>Headings</H4>
<H5>Headings</H5>
<H6>Headings</H6>
A marcação <P> é utilizada para definir o início de um novo parágrafo,
deixando uma linha em branco entre cada parágrafo. HTML não reconhece o caractere
de quebra de linha dos editores de texto. Mesmo que exista uma linha em branco, os
clientes Web só reconhecem o início de um novo parágrafo mediante a marcação
apropriada.
A marcação <BR> faz uma quebra de linha sem acrescentar espaço extra entre
as linhas. Veja a diferença do uso de <P> e <BR>:
Vamos separar esta sentença com marcação de parágrafo.<p> Para verificar a diferença.
Diferença quando separamos duas linhas utilizando <br> a marcação de quebra de linha <br> Deu pra notar?
O principal poder do HTML vem da sua capacidade de interligar partes de um
texto (e também imagens) a outros documentos. Os clientes exibem em destaque estas
áreas ou pontos chaves (normalmente com cores diferentes ou sublinhado) para indicar
que se trata de um link, ou interligação, no hipertexto.
Vamos separar esta sentença com marcação de parágrafo.
Para verificar a diferença.
Diferença quando separamos duas linhas utilizando a marcação de quebra de linha Deu pra notar?
171
A marcação <A>, que define o ponto de partida para os links, é denominada de
âncora. Para incluir uma âncora em seu documento:
• Inicie a âncora com <A (Há um espaço depois de A.)
• Especifique o documento a ser interligado, inserindo o parâmetro
HREF="filename" seguido do sinal: > Obs.:(HREF significa Hypertext
Reference)
• Insira o texto que vai funcionar como link no documento corrente
• Anote a marcação de final da âncora: </A>.
Um exemplo de referência a um hipertexto: <A HREF="index.htm">Índice</A>
Que resulta no link “Índice”.
A palavra "Índice" é definida como o marcador do link para se chegar ao
documento index.htm, que está no mesmo diretório do documento corrente. Ou seja,
"Índice" aparece em destaque (normalmente em azul) e se você clicar nessa palavra será
exibido o documento apontado - index.htm
É possível interligar documentos em outro diretório especificando-se o caminho
relativo a partir do documento corrente, em relação ao que está sendo interligado.
Por exemplo, um link para o arquivo link1.htm localizado no subdiretório exemplos
seria assim:
<A HREF="exemplos/link1.htm"> Página Teste </A>
Que resulta no link “Página Teste”.
Estes são dos denominados links relativos. É também possível usar o caminho
completo, calculado a partir do diretório raiz do servidor, do arquivo desejado. Para
isso, utiliza-se a sintaxe padrão do sistema UNIX.
Algumas regras que devem ser observadas são:
• Utiliza-se a barra deitada / para separar diretórios e não a barra invertida \ usada
no MS_DOS.
172
• No DOS e no Windows 3.1 a extensão do arquivo é limitada a 3 letras, e os
arquivos index.htm e index.html representam o mesmo arquivo, no Windows 95
e no Unix estes dois nomes representam arquivos diferentes.
• O UNIX faz distinção entre maiúsculas e minúsculas no nome do arquivo e o
arquivo index.htm é diferente do arquivo INDEX.HTM que é diferente de
Index.htm
Exemplos:
Caso quisera-se referenciar um diretório a partir do "raiz" do seu servidor www,
inicie a notação com /. Isto é, caso tenha-se uma notação desta forma:
<A HREF="/imagens/incon1.gif">
Significa que o arquivo incon1.gif deverá ser buscado no diretório imagens que
está imediatamente acima do diretório raiz do seu servidor www.
Já o link:
<A HREF="../tutorial/interlig.htm">
Significa que a partir do diretório atual, volte para o diretório anterior, vá para o
sub-diretório tutorial deste diretório e leia o arquivo interlig.htm.
A World Wide Web utiliza-se das Uniform Resource Locators (URLs) para
especificar a localização de arquivos em servidores. Uma URL inclui o tipo de recurso
acessado (p.e, gopher, WAIS), o endereço do servidor, e a localização do arquivo.
Escreve-se de acordo com o esquema abaixo:
protocolo://servidor[:port]/path/filename
Onde protocolo é uma das seguintes definições:
file um arquivo no seu sistema local, ou servidor de ftp http um arquivo em um servidor World Wide Web gopher um arquivo em um servidor Gopher WAIS um arquivo em um servidor WAIS news um Usenet Newsgroup telnet uma conexão Telnet mailto envia um email para o endereço especificado
173
Por exemplo, para incluir um link para o HTML Beginner’s Guide, em um
documento, deve ser usado:
<A HREF="http://www.ncsa.uiuc.edu/General/Internet/WWW/ HTMLPrimer.html"> NCSA's Beginner's Guide to HTML</A>
O que torna a sentença “NCSA's Beginner's Guide to HTML” um link para tal
documento.
O comando:
<A HREF="mailto:[email protected]"> Para contactar o CDCC clique aquí </A>
Chama o programa de e-mail do seu navegador e envia um email para o CDCC.
O HTML permite que se façam ligações entre diferentes trechos de um
documento. Pode-se apontar uma palavra ou trecho de um texto utilizando uma âncora
de nome (named anchor). Este recurso é bastante usado na geração de índices de
conteúdo de uma página que seja muito longa.
A sequência passo a passo é:
1. Defina o "ponto de partida", atribuindo a ele um nome qualquer - no
exemplo Topo -, precedido do caracter #,da seguinte forma: Para ir para
o Topo da página clique aqui Para ir para o Topo da página
clique <a href="#topo"> aqui</a>.
2. Defina o "ponto de chegada", atribuindo a ele uma âncora de nome, com
o nome correspondente ao do ponto de partida, assim:
O principal poder do HTML vem <a name="topo">da sua capacidade
</a> de interligar ...
Para fazer links com sessões de outros documentos o processo é o mesmo da
sessão anterior. Faz-se uma âncora normalmente, e apenas é acrescentado, após a url do
documento de destino, o sinal # e uma palavra, ou identificador. Por exemplo:
Este é um <a href="index.htm#ultimo">link</a> para o último item do
índice deste tutorial. E no arquivo index.htm criaríamos um link do tipo <a
name="ultimo"> ... </a>.
174
Para criar uma lista não numerada:
1. Comece com a marcação de início de lista: <UL>.
2. Insira a marcação <LI> antes de cada item da lista item. (Não é necessário fechar a
marcação com </LI> )
3. Encerre com a marcação de fim de lista: </UL>.
Abaixo o exemplo de uma lista:
<UL> <LI> maçãs <LI> bananas <LI> peras </UL>
Vai aparecer assim:
• maçãs • bananas • peras
Uma lista numerada - ou ordenada - é semelhante a uma lista não numerada,
exceto porque utiliza marcação <OL> ao invés de <UL>. Os itens são identificados
utilizando-se a mesma notação <LI>.
Uma lista criada assim:
<OL> <LI> laranjas <LI> peras <LI> uvas </OL>
Resulta neste formato:
1. laranjas 2. peras 3. uvas
Uma lista de definições normalmente consiste em alternar um termo (abreviado
como DT) e uma definição (abreviado como DD). O Netscape mostra a definição em
nova linha com outro alinhamento.
Exemplo de uma lista de definição:
<DL> <DT> BANANA <DD> Banana é uma fruta de cor amarela <DT> PERA <DD> Pera é uma fruta de cor verde </DL>
BANANA Banana é uma fruta de cor amarela
PERA Pera é uma fruta de cor verde
175
As entradas <DT> e <DD> podem conter vários parágrafos (separados por <P>),
listas, ou outras definições. A marcação <DD> pode também ser utilizada, fora de uma
lista de definições como se fosse uma tabulação (insere um espaço no início da frase).
A marcação <PRE> (preformatted) delimita uma área de texto em que espaços,
novas linhas e tabulações são mantidas. Ou seja, o texto será apresentado exatamente da
forma como foi digitado, mesmo que não haja marcações do html. É uma forma de se
preservar o formato de um texto.
Este recurso é utilizado, por exemplo, para listas de programas. Vejamos um
exemplo:
<PRE> #!/bin/csh cd $SCR cfs get myinfile:mycfsdir/myinfile fc -02 -o mya.out mysrc.f mya.out rm * </PRE>
#!/bin/csh cd $SCR cfs get mysrc.f:mycfsdir/mysrc.f fc -02 -o mya.out mysrc.f mya.out rm *
Podem ser definidos links dentro de textos pré-formatados. No entanto, deve-se
evitar utilizar outros caracteres de marcações em áreas <PRE>. Isto porque caracteres
como <, >, e & possuem um significado específico no HTML. O ideal é utilizar as
sequências especiais, (< > e & respectivamente) sempre que precisar
representar esses caracteres.
O HTML permite que se apliquem estilos específicos a palavras ou sentenças,
que alteram a forma como a fonte básica é apresentada na tela.
Vamos ver algumas opções:
<B> texto em negrito </B> resulta em texto em negrito <I> texto em itálico </I> resulta em texto em itálico <TT> fonte com espaçamento fixo </TT> normalmente produz texto na fonte Courier ou equivalente.
Temos também o comando <FONT> </FONT> que permite alterar o tamanho
da letra e a cor do texto. Por exemplo:
176
<FONT color="#ff0000" SIZE=+5 > V</FONT>eja <FONT color="#00ff00" SIZE=1 > como ficou. </FONT>
Veja como ficou.
O tamanho da fonte é especificado em números de 1 (menor) até 7 (maior fonte
possível) ou em números relativos (por exemplo +1 -2 +5), calculados em relação à
fonte padrão do navegador. O resultado destes comandos não são muito previsíveis,
dependem do navegador que está sendo utilizado e da fonte padrão para a qual ele está
configurado.
O método de descrição de cores do HTML consiste em indicar os valores das
componentes Red, Green e Blue (RGB) em hexadecimal, variando de 00 até ff
(equivalente a 255 em decimal e que seria o valor máximo desta cor). Também
podemos especificar a cor pelo seu nome. Algumas cores são:
#000000 Black #ffffff White #ff0000 Red #00ff00 Green
#0000ff Blue #ffff00 Yellow #c0c0c0 Grey #ff7f00 Orange
Em geral, os navegadores possuem um conjunto de cores padrões para exibição
da tela; são elas grey (C0C0C0) para o fundo da tela, black (00000) para texto, Blue
(0000FF) para os links e purple (9900CC) para links visitados. Pode-se modificar esses
valores para a página colocando no comando <BODY>, no início da página. Por
exemplo:
<BODY BGCOLOR="#000000" TEXT="#FFFFFF" LINK="Pink"
VLINK="#70DB93">
Define uma página com fundo branco, letras pretas, links em Pink e links
visitados em Aquamarine.
De um modo geral a maioria dos navegadores mostra corretamente os caracteres
acentuados, porém se o editor não aceitar acentuação direta pelo teclado, pode-se usar a
seguinte sequencia de caracteres especiais para acentuação:
Caractere Notação
177
Acento agudo &xacute; onde x é uma letra qualquer, maiúscula ou minúscula
Acento grave &xgrave; onde x é uma letra qualquer, maiúscula ou minúscula
Acento circunflexo ◯ onde x é uma letra qualquer, maiúscula ou minúscula
Letra com til &xtilde; onde x é uma letra qualquer, maiúscula ou minúscula
Letra com trema &xuml; onde x é uma letra qualquer, maiúscula ou minúscula
Cedilha Ç = Ç e ç= ç
As imagens dentro de uma página devem estar preferencialmente no formato
".gif". O Netscape e o MSExplorer conseguem decodificar outros formatos como o
".jpg" e ".rgb", mas esta capacidade não é comum a todos os programas.
Utiliza-se a seguinte notação para incluir uma imagem:
<img src="diretório/arquivo">
Por exemplo:
<IMG SRC="bell.gif" WIDTH="45" HEIGHT="40" ALT="campainha">
Insere o arquivo bell.gif. Opcionalmente foi especificado também o tamanho
(WIDTH e HEIGHT) em pixels da imagem, isto não é obrigatório, mas facilita o
trabalho do Browser para desenhar a página e é recomendado usar. O item
ALT="campainha" indica o texto alternativo que aparece no lugar da imagem se ela não
for carregada por quem estiver vendo a página (por exemplo se a transmissão for
interrompida antes da imagem chegar totalmente).
Toda imagem incluída pode ser posicionada (align=...) na tela das seguintes
formas: TOP, MIDDLE, BOTTOM, LEFT e RIGHT. As três primeiras opções definem
a posição vertical da imagem com relação ao texto. Veja os exemplos:
<IMG SRC="bbola.gif" ALIGN="top" >
<IMG SRC="bbola.gif" ALIGN="middle" >
<IMG SRC="bbola.gif" ALIGN="bottom" >
As duas últimas definem a posição da imagem na página, a direita ou esquerda:
<IMG SRC="bbola.gif" ALIGN="right" >
178
<IMG SRC="bbola.gif" ALIGN="left">
Caso seja omitida a opção "align", a imagem aparecerá a esquerda da página.
Uma imagem pode ser ainda um botão sensível: Para isso basta incluir uma
imagem no interior de uma âncora.
<a href="index.htm"><img src="indice.gif"></a>
A marcação <HR> produz uma linha horizontal no documento. É possível
controlar a espessura das barras, utilizando-se o atributo “size=” e o comprimento da
linha com o atributo “width=”. Veja alguns exemplos:
<HR size=10 width=300> produz uma linha de 10 pixels de espessura e 300 pixels de comprimento.
<HR width="80%"> produz uma linha que ocupa 80% da largura da página.
<HR size=50 width=2> produz uma linha vertical.
A estrutura básica de uma tabela é simples. Inicia-se a tabela com o comando
<TABLE> e termina-se com </TABLE>. Dentro da tabela inicia-se cada linha com
<TR> e termina-se com </TR> e dentro de cada linha inicia-se uma coluna com <TD> e
termina-se com </TD>. Uma Tabela 2 X 2 seria então:
<TABLE > <TR> <TD> a </TD> <TD> b </TD> </TR> <TR> <TD> c </TD> <TD> d </TD> </TR> </TABLE>
a b
c d
Caso queira-se que a tabela tenha bordas, acrescenta-se o atributo BORDER no
começo da tabela. Pode-se também especificar a espessura da borda em pixels, por
exemplo, para uma borda de 5 pixels de espessura faz-se BORDER=5. Veja:
<TABLE BORDER=5> <TR> <TD> a </TD> <TD> b </TD> </TR> <TR> <TD> c </TD> <TD> d </TD> </TR> </TABLE>
a b
c d
No lugar de <TD> </TD> para definir uma célula pode-se usar <TH> </TH>,
que indica que esta célula é um cabeçalho (header). O texto dentro de uma célula
179
definida como cabeçalho é mostrado em negrito e centralizado. Outro atributo é
<CAPTION> </CAPTION>, que define a legenda da tabela:
<TABLE BORDER><CAPTION> Exemplo </CAPTION> <TR> <TH> Título 1 </TH> <TH> Título 2 </TH> </TR> <TR> <TD> c </TD> <TD> d </TD> </TR> </TABLE>
Exemplo
Título 1 Título 2
c d
Pode-se mudar os atributos de cada célula dentro de uma tabela com os seguintes
comandos:
Atributo Descrição
ALIGN (LEFT, CENTER, RIGHT)
Alinhamento horizontal da célula
VALIGN (TOP, MIDDLE, BOTTOM)
Alinhamento vertical da célula
COLSPAN=n Número (n) de colunas que uma célula ocupa
ROWSPAN=n Número de linhas que uma célula ocupa
BGCOLOR= Cor a ser usada para preencher a célula (só funciona
no Netscape 3)
WIDTH= Largura da célula
CELLPADDING Espaço a ser acrescentado entre uma coluna e outra
Exemplo:
<CENTER> <TABLE BORDER=10 WIDTH="80%" CELLPADDING=5> <TR> <TD COLSPAN=2 ALIGN=CENTER> aaa </TD> <TD BGCOLOR="#00CCCC"> bbb </TD> </TR> <TR> <TD ROWSPAN=2 VALIGN=BOTTOM> ccc </TD> <TD ALIGN=RIGHT> ddd </TD> <TD> eee </TD> </TR> <TR> <TD> fff </TD> <TD> ggg </TD> </TR> </TABLE> </CENTER>
Que resulta em:
aaa bbb
ccc
ddd eee
fff ggg
180
Anexo 4
Programação utilizada para gerar novo modelo de página em html usada para interface entre o computador e a placa. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <title>µC/HTTPs</title> <meta name="generator" content="BBEdit 9.3"> <style type="text/css" title="text/css"> html { height:100%; } body { background:#666666; color:#0a0a0a; font-family:Arial, sans-serif; font-size:14px; line-height:21px; height:100%; } * { font-size:1em; margin:0; padding:0; } ul, ol { padding-left:1.6em; } option { min-width: 1.5em; } input { font-size:20px; } input.bluebutton {background:#dde2e6; border:2px solid #000000; color:#223d50; font-weight:bold; padding:3px 7px 3px 7px; } table, td { border:none; margin:0; padding:0; } #controls { float:right; margin:0 100px 0 0; width:370px; } #copyright { clear:both; font-size:14px; padding:50px 0 0 0; text-align:right; }
181
#information { float:left; margin:0 30px 0 0; width:370px; } #information a:link { color:#cccccc; } #information a:visited { color:#cccccc; } #information a:hover { color:#fa9500; } #information a:active { color:#fa9500; } #pagebody { background:#223d50; padding:0 0 150px 0; } #pagebody h2 { color:#ffffff; font-size:25px; font-weight:bold; margin:10px 10px 0 0; } #pagebody p { color:#ffffff; margin:3px 3px 3px 3px; } #pagebody p.alertbox { background:#fa9500; margin:30px 20px 14px 20px; padding:5px 10px 5px 10px; } #pagewrapper { background:#666666; margin:0 auto 0 auto; width:800px; } #topbanner { background:#dde2e6; padding:10px; } #topbanner p { color:#223d50; } </style> </head> <body> <div id="pagewrapper"> <div id="topbanner"> <table width="100%" cellpadding=8> <tr> <td> <img src="logo.gif" alt="" width="312" height="60"> </td> <td align=right> <p><b>Trabalho de Conclusão de Curso</p>
182
<p>Diogo do Nascimento Serra</p> <p>Orientador: Prof. Dr. Galdenoro Botura Jr.</b></p> </td> </tr> </table> </div> <div id="pagebody"> <div id="controls"> <h2>Comandos</h2> <table> <tr> <td> <form action="index.html" method="POST"> <p> <input name="LED" type="hidden" value="LED1"> <input type="submit" value="Q" accesskey="q" class="bluebutton"> </p> </form> </td> <td> <form action="index.html" method="POST"> <p> <input name="LED" type="hidden" value="LED2"> <input type="submit" value="w" accesskey="w" class="bluebutton">
183
</p> </form> </td> <td> <form action="index.html" method="POST"> <p> <input name="LED" type="hidden" value="LED3"> <input type="submit" value="E" accesskey="e" class="bluebutton"> </p> </form> </td> </tr> </table> <table> <tr> <td> <form action="index.html" method="POST"> <p> <input name="LED" type="hidden" value="LED4"> <input type="submit" value="A" accesskey="a" class="bluebutton"> </p> </form> </td> <td> <form action="index.html" method="POST"> <p> <input name="LED" type="hidden" value="LED5"> <input type="submit" value="S" accesskey="s" class="bluebutton"> </p> </form>
184
</td> <td> <form action="index.html" method="POST"> <p> <input name="LED" type="hidden" value="LED6"> <input type="submit" value="D" accesskey=d" class="bluebutton"> </p> </form> </td> </tr> </table> </div> </div> </div> </body> </html> A seguir encontra-se a programação da página HTML original do exemplo 5 do kit Renesas. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <title>µC/HTTPs</title>
185
<meta name="generator" content="BBEdit 9.3"> <style type="text/css" title="text/css"> html { height:100%; } body { background:#666666; color:#0a0a0a; font-family:Arial, sans-serif; font-size:14px; line-height:21px; height:100%; } * { font-size:1em; margin:0; padding:0; } ul, ol { padding-left:1.6em; } option { min-width: 1.5em; } input { font-size:10px; } input.bluebutton {background:#dde2e6; border:2px solid #000000; color:#223d50; font-weight:bold; padding:3px 5px 3px 5px; } table, td { border:none; margin:0; padding:0; } #controls { float:right; margin:0 30px 0 0; width:370px; } #copyright { clear:both; font-size:10px; padding:30px 0 0 0; text-align:right; } #information { float:left; margin:0 30px 0 0; width:370px; } #information a:link { color:#cccccc; } #information a:visited { color:#cccccc; } #information a:hover { color:#fa9500; } #information a:active { color:#fa9500; } #pagebody { background:#223d50; padding:0 0 30px 0; } #pagebody h2 { color:#ffffff; font-size:18px; font-weight:bold; margin:30px 0 14px 30px; } #pagebody p { color:#ffffff; margin:0 30px 14px 30px; } #pagebody p.alertbox { background:#fa9500; margin:30px 20px 14px 20px; padding:5px 10px 5px 10px; } #pagewrapper { background:#666666; margin:0 auto 0 auto; width:800px; }
186
#topbanner { background:#dde2e6; padding:20px; } #topbanner p { color:#223d50; } </style> </head> <body> <div id="pagewrapper"> <div id="topbanner"> <img src="logo.gif" alt="" width="212" height="41"> <p><strong>A Member of the µC/TCP-IP Product Family</strong></p> </div> <div id="pagebody"> <div id="information"> <p class="alertbox">Your HTTP server is working properly.</p> <p><a href="http://www.micrium.com/products/rtos/kernel/rtos.html">µC/OS-III</a> Version: ${OS_VERSION}</p> <p><a href="http://www.micrium.com/products/tcp-ip/tcp-ip.html">µC/TCP-IP</a> Version: ${NET_VERSION}</p> </div> <div id="controls"> <h2>Eval Board Status</h2> <p>Temperature sensor: ${TEMP_C}°C</p> <p>Temperature sensor: ${TEMP_F}°F</p> <h2>Eval Board Controls</h2>
187
<table> <tr> <td> <form action="index.html" method="POST"> <p> <input name="LED" type="hidden" value="LED1"> <input type="submit" value="Toggle LED 15" class="bluebutton"> </p> </form> </td> <td> <form action="index.html" method="POST"> <p> <input name="LED" type="hidden" value="LED2"> <input type="submit" value="Toggle LED 4" class="bluebutton"> </p> </form> </td> </tr> </table> </div> <div id="copyright"> <p>Copyright 2010 Micriµm Inc.</p> </div> </div> </div>
188
</body> </html>
189
Anexo 5
Programação completa do arquivo “app_html.c” encontrado no exemplo 5 do programa renesas com as alterações para que funcione conforme necessidades da movimentação do carro. /* ********************************************************************************************************* * EXAMPLE CODE * * (c) Copyright 2009-2010; Micrium, Inc.; Weston, FL * * All rights reserved. Protected by international copyright laws. * * Please feel free to use any application code labeled as 'EXAMPLE CODE' in * your application products. Example code may be used as is, in whole or in * part, or may be used as a reference only. * * Please help us continue to provide the Embedded community with the finest * software available. Your honesty is greatly appreciated. * * You can contact us at www.micrium.com. ********************************************************************************************************* */ /* ********************************************************************************************************* *
190
* HTTP SERVER EXAMPLE FILE * * TEMPLATE * * Filename : app.c * Version : V1.00 * Programmer(s) : JJL * AA * SR ********************************************************************************************************* * Note(s) : (1) Assumes the following versions (or more recent) of software modules are included in * the project build : * * (a) uC/TCP-IP V2.10 * (b) uC/OS-III V3.01.3 * (c) uC/LIB V1.31 * (d) uC/CPU V1.25 ********************************************************************************************************* */ /* ********************************************************************************************************* * INCLUDE FILES ********************************************************************************************************* */ #include <includes.h> #include <webpages.h>
191
/* ********************************************************************************************************* * LOCAL DEFINES ********************************************************************************************************* */ #define HTTPs_VAL_REQ_BUF_LEN 20u #define HTML_LED_INPUT_NAME "LED" #define HTML_LED1_TOGGLE_INPUT_VALUE "LED1" #define HTML_LED2_TOGGLE_INPUT_VALUE "LED2" #define HTML_LED3_TOGGLE_INPUT_VALUE "LED3" #define HTML_LED4_TOGGLE_INPUT_VALUE "LED4" #define HTML_LED5_TOGGLE_INPUT_VALUE "LED5" #define HTML_LED6_TOGGLE_INPUT_VALUE "LED6" #define LED1 13u #define LED2 14u #define LED3 15u #define LED4 4u #define LED5 5u #define LED6 6u /*$PAGE*/ /* ********************************************************************************************************* * LOCAL GLOBAL VARIABLES *********************************************************************************************************
192
*/ static CPU_INT16S AppTempSensorDegC; static CPU_INT16S AppTempSensorDegF; /* ********************************************************************************************************* * LOCAL MACRO'S ********************************************************************************************************* */ #define APP_TASK_STOP(); { while (DEF_ON) { \ ; \ } \ } #define APP_TEST_FAULT(err_var, err_code) { if ((err_var) != (err_code)) { \ APP_TASK_STOP(); \ } \ } /* ********************************************************************************************************* * LOCAL FUNCTION PROTOTYPES ********************************************************************************************************* */ static void App_TempSensorUpdate(void);
193
/*$PAGE*/ /* ********************************************************************************************************* * AppHTTPs_Init * * Description : Initialize HTTP server. * * Arguments : none. * * Returns : none. * * Notes : none. ********************************************************************************************************* */ void AppHTTPs_Init (void) { CPU_BOOLEAN cfg_success; cfg_success = HTTPs_Init(); APP_TEST_FAULT(cfg_success, DEF_OK); cfg_success = Apps_FS_Init(); APP_TEST_FAULT(cfg_success, DEF_OK);
194
cfg_success = Apps_FS_AddFile((CPU_CHAR *)&STATIC_INDEX_HTML_NAME, (CPU_CHAR *)&Index_html, (CPU_INT32U) STATIC_INDEX_HTML_LEN); APP_TEST_FAULT(cfg_success, DEF_OK); /* cfg_success = Apps_FS_AddFile((CPU_CHAR *)&STATIC_LOGO_GIF_NAME, (CPU_CHAR *)&Logo_Gif, (CPU_INT32U) STATIC_LOGO_GIF_LEN); APP_TEST_FAULT(cfg_success, DEF_OK); */ BSP_Temp_Init(); App_TempSensorUpdate(); } /*$PAGE*/ /* ********************************************************************************************************* * App_TempSensorUpdate() * * Description : Monitor temperature sensor. * * Argument(s) : none. * * Return(s) : none. * * Caller(s) : AppTaskStart().
195
* * Note(s) : none. ********************************************************************************************************* */ static void App_TempSensorUpdate (void) { static CPU_INT16S temp_sensor = 0; AppTempSensorDegC = (CPU_INT16S)BSP_Temp_Rd(); AppTempSensorDegF = (AppTempSensorDegC * 9u / 5u) + 32u; temp_sensor++; } /*$PAGE*/ /* ********************************************************************************************************* * HTTPs_ValReq() * * Description : Callback function handling dynamic variable substitution from HTML file. * * Argument(s) : p_tok Pointer to string containing the name of the HTML embedded token. * * p_val Pointer to string that will receive the value of the HTML embedded token. * * Return(s) : DEF_OK, if value of token returned successfully.
196
* * DEF_FAIL, otherwise. * * Caller(s) : HTTPs_HTML_FileTokParse(). * * Note(s) : (1) This is a callback function that MUST be implemented in your application. * * (2) 'p_val' returned by HTTPs_ValReq() MUST reference a global array in order to prevent * the caller from accessing an out-of-scope array defined within HTTPs_ValReq(). ********************************************************************************************************* */ CPU_BOOLEAN HTTPs_ValReq (CPU_CHAR *p_tok, CPU_CHAR **p_val) { static CPU_CHAR val_buf[HTTPs_VAL_REQ_BUF_LEN]; #if (LIB_VERSION >= 126u) CPU_INT32U ver; #elif (LIB_STR_CFG_FP_EN == DEF_ENABLED) CPU_FP32 ver; #endif OS_TICK os_time_tick; #if (LIB_STR_CFG_FP_EN == DEF_ENABLED) CPU_FP32 os_time_sec; #else CPU_INT32U os_time_sec; CPU_INT32U os_time_ms; CPU_SIZE_T os_time_len; #endif OS_ERR os_err;
197
(void)Str_Copy(&val_buf[0], "%%%%%%%%"); *p_val = &val_buf[0]; /* --------------------- OS VALUES -------------------- */ if (Str_Cmp(p_tok, "OS_VERSION") == 0) { #if (LIB_VERSION >= 126u) #if (OS_VERSION > 300u) ver = OS_VERSION / 1000; (void)Str_FmtNbr_Int32U(ver, 2, DEF_NBR_BASE_DEC, ' ', DEF_NO, DEF_NO, &val_buf[0]); val_buf[2] = '.'; ver = (OS_VERSION / 10) % 100; (void)Str_FmtNbr_Int32U(ver, 2, DEF_NBR_BASE_DEC, '0', DEF_NO, DEF_NO, &val_buf[3]); val_buf[5] = '.'; ver = (OS_VERSION / 1) % 10; (void)Str_FmtNbr_Int32U(ver, 1, DEF_NBR_BASE_DEC, '0', DEF_NO, DEF_YES, &val_buf[6]); val_buf[8] = '\0'; #else ver = OS_VERSION / 100; (void)Str_FmtNbr_Int32U(ver, 2, DEF_NBR_BASE_DEC, ' ', DEF_NO, DEF_NO, &val_buf[0]); val_buf[2] = '.'; ver = (OS_VERSION / 1) % 100; (void)Str_FmtNbr_Int32U(ver, 2, DEF_NBR_BASE_DEC, '0', DEF_NO, DEF_YES, &val_buf[3]); val_buf[5] = '\0';
198
#endif #elif (LIB_STR_CFG_FP_EN == DEF_ENABLED) #if (OS_VERSION > 300u) ver = (CPU_FP32)OS_VERSION / 1000; (void)Str_FmtNbr_32(ver, 2, 2, ' ', DEF_NO, &val_buf[0]); ver = (CPU_FP32)OS_VERSION / 10; (void)Str_FmtNbr_32(ver, 0, 1, '\0', DEF_YES, &val_buf[6]); #else ver = (CPU_FP32)OS_VERSION / 100; (void)Str_FmtNbr_32(ver, 2, 2, '\0', DEF_YES, &val_buf[0]); #endif #endif } else if (Str_Cmp(p_tok, "OS_TIME" ) == 0) { os_time_tick = (OS_TICK )OSTimeGet(&os_err); #if (LIB_STR_CFG_FP_EN == DEF_ENABLED) os_time_sec = (CPU_FP32)os_time_tick / OS_CFG_TICK_RATE_HZ; (void)Str_FmtNbr_32(os_time_sec, 7u, 3u, '\0', DEF_YES, &val_buf[0]); #else os_time_sec = (CPU_INT32U)os_time_tick / OS_CFG_TICK_RATE_HZ; (void)Str_FmtNbr_Int32U(os_time_sec, 7u, DEF_NBR_BASE_DEC, '\0', DEF_NO, DEF_YES, &val_buf[0]); (void)Str_Cat(&val_buf[0], "."); os_time_len = Str_Len(&val_buf[0]); os_time_ms = (CPU_INT32U)os_time_tick % OS_CFG_TICK_RATE_HZ; os_time_ms *= 1000 / OS_CFG_TICK_RATE_HZ; (void)Str_FmtNbr_Int32U(os_time_ms, 3u, DEF_NBR_BASE_DEC, '0', DEF_NO, DEF_YES, &val_buf[os_time_len]);
199
#endif /*$PAGE*/ /* ----------- NETWORK PROTOCOL SUITE VALUES ---------- */ } else if (Str_Cmp(p_tok, "NET_VERSION") == 0) { #if (LIB_VERSION >= 126u) #if (NET_VERSION > 205u) ver = NET_VERSION / 10000; (void)Str_FmtNbr_Int32U(ver, 2, DEF_NBR_BASE_DEC, ' ', DEF_NO, DEF_NO, &val_buf[0]); val_buf[2] = '.'; ver = (NET_VERSION / 100) % 100; (void)Str_FmtNbr_Int32U(ver, 2, DEF_NBR_BASE_DEC, '0', DEF_NO, DEF_NO, &val_buf[3]); val_buf[5] = '.'; ver = (NET_VERSION / 1) % 100; (void)Str_FmtNbr_Int32U(ver, 2, DEF_NBR_BASE_DEC, '0', DEF_NO, DEF_YES, &val_buf[6]); val_buf[8] = '\0'; #else ver = NET_VERSION / 100; (void)Str_FmtNbr_Int32U(ver, 2, DEF_NBR_BASE_DEC, ' ', DEF_NO, DEF_NO, &val_buf[0]); val_buf[2] = '.'; ver = (NET_VERSION / 1) % 100; (void)Str_FmtNbr_Int32U(ver, 2, DEF_NBR_BASE_DEC, '0', DEF_NO, DEF_YES, &val_buf[3]); val_buf[5] = '\0'; #endif
200
#elif (LIB_STR_CFG_FP_EN == DEF_ENABLED) #if (NET_VERSION > 205u) ver = (CPU_FP32)NET_VERSION / 10000; (void)Str_FmtNbr_32(ver, 2, 2, ' ', DEF_NO, &val_buf[0]); ver = (CPU_FP32)NET_VERSION / 100; (void)Str_FmtNbr_32(ver, 0, 2, '\0', DEF_YES, &val_buf[6]); #else ver = (CPU_FP32)NET_VERSION / 100; (void)Str_FmtNbr_32(ver, 2, 2, '\0', DEF_YES, &val_buf[0]); #endif #endif /* ---------------- APPLICATION VALUES ---------------- */ } else if (Str_Cmp(p_tok, "TEMP_C") == 0) { (void)Str_FmtNbr_Int32S(AppTempSensorDegC, 3, DEF_NBR_BASE_DEC, '\0', DEF_NO, DEF_YES, &val_buf[0]); } else if (Str_Cmp(p_tok, "TEMP_F") == 0) { (void)Str_FmtNbr_Int32S(AppTempSensorDegF, 3, DEF_NBR_BASE_DEC, '\0', DEF_NO, DEF_YES, &val_buf[0]); } if ((Str_Cmp(p_tok, "TEMP_C") == 0) || /* Update temperature values. */ (Str_Cmp(p_tok, "TEMP_F") == 0)) { App_TempSensorUpdate(); } return DEF_OK;
201
} /*$PAGE*/ /* ********************************************************************************************************* * HTTPs_ValRx() * * Description : Callback function handling POST action for every name-value pair received. * * Argument(s) : p_var Pointer to string containing the name of the HTTP POST variable. * * p_val Pointer to string containing the value of the HTTP POST variable. * * Return(s) : DEF_OK, if value of token returned successfully. * * DEF_FAIL, otherwise. * * Caller(s) : HTTPs_ProcessCGIList(). * * Note(s) : (1) This is a callback function that MUST be implemented in your application. ********************************************************************************************************* */ int i=0; CPU_BOOLEAN HTTPs_ValRx (CPU_CHAR *p_var, CPU_CHAR *p_val) { CPU_INT16U cmp_str; CPU_BOOLEAN ret_val;
202
LED_On(0); ret_val = DEF_FAIL; cmp_str = Str_Cmp((CPU_CHAR *)p_var, (CPU_CHAR *)HTML_LED_INPUT_NAME); if (cmp_str == 0) { cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 1. */ (CPU_CHAR *)HTML_LED1_TOGGLE_INPUT_VALUE); if (cmp_str == 0) { //LED_Toggle(LED1); LED_Off(14); LED_Off(15); for (i=0;i<20000000;i++) {} LED_On(14); LED_On(15); ret_val = DEF_OK; } cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 2. */ (CPU_CHAR *)HTML_LED2_TOGGLE_INPUT_VALUE); if (cmp_str == 0) { //LED_Toggle(LED2); LED_Off(15); for (i=0;i<20000000;i++) {} LED_On(15); ret_val = DEF_OK; } cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 3. */
203
(CPU_CHAR *)HTML_LED3_TOGGLE_INPUT_VALUE); if (cmp_str == 0) { //LED_Toggle(LED3); LED_Off(15); LED_Off(4); for (i=0;i<20000000;i++) {} LED_On(15); LED_On(4); ret_val = DEF_OK; } cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 4. */ (CPU_CHAR *)HTML_LED4_TOGGLE_INPUT_VALUE); if (cmp_str == 0) { //LED_Toggle(LED4); LED_Off(6); LED_Off(14); for (i=0;i<20000000;i++) {} LED_On(6); LED_On(14); ret_val = DEF_OK; } cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 5. */ (CPU_CHAR *)HTML_LED5_TOGGLE_INPUT_VALUE); if (cmp_str == 0) { //LED_Toggle(LED5); LED_Off(6); for (i=0;i<20000000;i++)
204
{} LED_On(6); ret_val = DEF_OK; } cmp_str = Str_Cmp((CPU_CHAR *)p_val, /* Toggle LED 6. */ (CPU_CHAR *)HTML_LED6_TOGGLE_INPUT_VALUE); if (cmp_str == 0) { //LED_Toggle(LED6); LED_Off(6); LED_Off(4); for (i=0;i<20000000;i++) {} LED_On(6); LED_On(4); ret_val = DEF_OK; } } return (ret_val); }
205
Anexo 6
206
207
208
209
210
211
212
213
214
Anexo 7
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
Bibliografia
[1] Como o Protocolo TCP/IP Funciona - Parte 1 – Clube do Hardware
http://www.clubedohardware.com.br/artigos/1351, acessado em 27 de Novembro de 209
[2] Como o Protocolo TCP/IP Funciona - Parte 1 – Clube do Hardware http://www.clubedohardware.com.br/artigos/1352, acessado em 27 de Novembro de 2009
[3] Redes wireless, parte 1: Uma introdução – Guia do Hardware http://www.guiadohardware.net/tutoriais/redes-wireless/, acessado em 14 de Novembro de 2009
[4] Redes wireless, parte 2: Padrões – Guia do Hardware http://www.guiadohardware.net/tutoriais/padroes-wireless/, acessado em 15 de Novembro de 2009
[5] Redes wireless, parte 5: Potência de transmissão e alcance – Guia do Hardware http://www.guiadohardware.net/tutoriais/potencia-alcance-wireless/, acessado em 15 de Novembro de 2009
[6] PC: um Guia Prático de Hardware e Interfaceamento; MENDONÇA, Alexandre, ZELENOVSKY, Ricardo. MZ Editora Ltda, 4ª Edição, 2006.
[7] Redes, Guia Prático; MORIMOTO, Carlos E. GDH Press e Sul Editores, 2008.
[8] Redes de Computadores; TORRES, Gabriel. Editora Nova Terra, 2009.
