tcc renato
TRANSCRIPT
1
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DA PARAÍBA
CAMPUS CAJAZEIRAS
DIREÇÃO DE ENSINO
UNIDADE ACADÊMICA DA ÁREA DE INDÚSTRIA
COORDENAÇÃO DO CURSO SUPERIOR DE TECNOLOGIA EM AUTOMAÇÃO
INDUSTRIAL
MÓDULO DE ACIONAMENTO E MONITORAMENTO VIA WEB
RENATO FRANKLIN RANGEL
TRABALHO DE CONCLUSÃO DE CURSO
ORIENTADOR: ÁGIO GONÇALVES DE MORAES FELIPE
COORIENTADOR: SAMUEL ALVES DA SILVA
Cajazeiras - PB, Março de 2012
2
Renato Franklin Rangel
MÓDULO DE ACIONAMENTO E
MONITORAMENTO VIA WEB
Trabalho de conclusão de curso apresentado
como parte das atividades para obtenção do
título de Tecnólogo em Automação Industrial, do
curso Superior de Tecnologia em Automação
Industrial do Instituto Federal da Paraíba, área
de concentração em Automação Industrial.
Orientador: Ágio Gonçalves de Moraes Felipe.
Coorientador: Samuel Alves da Silva.
Cajazeiras - PB, 2012
3
AGRADECIMENTOS
Agradeço primeiramente a Deus por ter me conferido saúde, sabedoria, enfim,
todas as condições necessárias para o desenvolvimento desse trabalho. Agradeço
também aos meus pais por me terem concedido dignidade e educação, a meus irmãos
e familiares como um todo pelo apoio e confiança, em especial a minha tia Julia que foi
imprescindível durante toda a minha graduação. Aos meus professores e orientadores
por toda a paciência e dedicação e aos colegas de curso pelo companheirismo.
4
RESUMO
O presente trabalho propõe a implementação de um dispositivo microcontrolado
capaz de controlar remotamente, equipamentos e processos industriais. Baseado no
microcontrolador PIC18F87J60, este dispositivo utiliza a internet como meio de
comunicação, fornecendo ao usuário versatilidade e baixo custo. O desenvolvimento
das páginas web é realizado a partir de códigos em HTML, CSS, XML, funções de
JavaScript e Ajax. Como exemplo de aplicação, o acionamento e monitoramento de um
sistema de iluminação a partir do módulo com internet embarcada, o qual
proporcionará ao usuário total controle sob a iluminação de um ambiente através de
uma pagina web.
Palavras-chave: microservidor, internet embarcada, acionamento e monitoramento
5
ABSTRACT
This work proposes the implementation of a micromachined device can remotely
control, equipment and industrial processes. Based on the PIC18F87J60
microcontroller, this device uses the Internet as a means of communication, providing
the user with versatility and low cost. The development of web pages is done from code
in HTML, CSS, XML, JavaScript and Ajax functions. As an application example, the
activation and monitoring of a system of illumination from the module with embedded
internet, which will give the user full control over the lighting of an environment through
a web page.
Keywords: Microserver, embedded internet, activation and monitoring
6
LISTA DE FIGURAS
Figura 1.1 – Esquema de acesso de dados remotamente ......................................... 13
Figura 2.1 – Modelo 360 IBM de 1964 ....................................................................... 17
Figura 2.2 – Estações conectadas ao meio usando padrão 10Base5........................ 23
Figura 2.3 – Estações conectadas ao meio usando padrão 10BaseT. ...................... 24
Figura 2.4 – Camadas do modelo de protocolos OSI. ................................................ 28
Figura 2.5 – Funcionamento da comunicação entre as camadas do modelo OSI......29
Figura 2.6 – Comunicação virtual no modelo OSI. ..................................................... 30
Figura 2.7 – Grupos das camadas do modelo OSI. ................................................... 31
Figura 2.8 – Comparação estrutural em relação às camadas entre os modelos de
referencia OSI e TCP/IP. ............................................................................................ 33
Figura 2.9 – Diagrama simplificado de um µC baseado na arquitetura Harvard. ....... 39
Figura 2.10 – Controlador Ethernet ENC28J60. ......................................................... 42
Figura 2.11 – Interface de rede 100/10BaseT ............................................................ 42
Figura 3.1 – Comportamento do modelo de referência e protocolos implementados na
pilha da microchip. ..................................................................................................... 44
Figura 3.2 – Comparação estrutural do Modelo de Referência TCP/IP e a Pilha
TCP/IP da Microchip.. ................................................................................................ 45
Figura 3.3 – Formato da imagem MPFS2. ................................................................. 48
Figura 3.4 – Formato do FAT de entrada MPFS2. ..................................................... 48
Figura 3.5 – Formato do bloco de dados. ................................................................... 49
Figura 3.6 – Diagrama de pinos do PIC18F87J60. .................................................... 51
Figura 3.7 – Diagrama de Blocos do PIC18F87J60. .................................................. 51
Figura 3.8 – Diagrama de bloco do Módulo Ethernet ................................................. 52
Figura 3.9 – Dimensões físicas do PIC18F87J60. ..................................................... 53
Figura 3.10 – Interface Ethernet PME10A de 10Mbps ............................................... 54
Figura 3.11 – Ambiente de trabalho do MPLAB IDE v8.50 ........................................ 56
7
Figura 3.12 – Ambiente de desenvolvimento do Proteus. .......................................... 57
Figura 3.13 – Gravador PICkit2. ................................................................................. 57
Figura 3.14 – Tela inicial do Dreamweaver CS3. ....................................................... 58
Figura 4.1 – Solicitação via GET. ............................................................................... 64
Figura 4.2 – Menu de arquivos que compõem a pilha ................................................ 66
Figura 4.3 – Circuito eletrônico em simulação. .......................................................... 68
Figura 4.4 – Compilador das páginas web. ................................................................ 69
Figura 4.5 – Informações referentes a página web compilada. .................................. 60
Figura 4.6 – Arquivo mpfsupload carregado no navegador. ....................................... 70
Figura 4.7 – Módulo montado para o controle de iluminação via web. ...................... 71
Figura 4.8 – Circuito condicionador de sinal .............................................................. 72
Figura 5.1 – Interface de gravação PICkit2. ............................................................... 74
Figura 5.2 – Exemplo de variáveis no arquivo status.xml. ......................................... 77
Figura 5.3 – Requisição ao arquivo xml. .................................................................... 78
Figura 5.4 – Esquemático do módulo conectado a rede e ao sistema de iluminação.
................................................................................................................................... 78
Figura 5.5 – Página de acesso ao controle de iluminação via Web ........................... 79
Figura 5.6 – Requisição de login e senha para acesso a página de controle ............ 80
Figura 5.7 – Status da sala (luzes acesas e sistema liberado) .................................. 81
Figura 5.8 – Status da sala (circuitos desligados e sistema bloqueado) .................... 81
8
SUMÁRIO
1 INTRODUÇÃO ........................................................................................................... 10
1.1 Fundamentação Teórica ...................................................................................... 12
1.2 Arquitetura Proposta ............................................................................................ 13
1.3 Objetivos .............................................................................................................. 15
1.3.1 Geral .............................................................................................................. 15
1.3.2 Específicos ..................................................................................................... 15
1.4 Estrutura do Trabalho .......................................................................................... 15
2 REVISÃO BIBLIOGRÁFICA ....................................................................................... 17
2.1 Desenvolvimento das Redes de Comunicação e da Internet ............................... 17
2.2 Surgimento do Padrão Ethernet ........................................................................... 22
2.3 Modelo de Referência OSI (MR-OSI) ................................................................... 27
2.4 Pilha de Protocolos TCP/IP – Arquitetura da Internet .......................................... 33
2.5 Microcontroladores ............................................................................................... 37
2.6 Internet Embarcada .............................................................................................. 41
3 FERRAMENTAS UTILIZADAS NO DESENVOLVIMENTO DO PROJETO ................ 43
3.1 Pilha TCP/IP da Microchip® ................................................................................. 43
3.1.1 Servidor HTTP da Microchip® ....................................................................... 46
3.1.2 Microchip File System 2 (MPFS2) .................................................................. 47
3.2 Microcontrolador PIC18F87J60 ............................................................................ 49
3.3 Especificação de Hardware .................................................................................. 53
3.4 MPLAB IDE .......................................................................................................... 55
3.5 PROTEUS ............................................................................................................ 56
3.6 GRAVADOR PICkit2 ............................................................................................ 57
3.7 Ferramentas para o Desenvolvimento de Páginas Web ...................................... 58
3.7.1 Dreamweaver ................................................................................................. 58
3.6.2 TECNOLOGIAS PARA APLICAÇÕES WEB ................................................. 59
9
4 IMPLEMENTAÇÃO DO PROJETO ............................................................................ 62
4.1 Desenvolvimento do Software .............................................................................. 62
4.1.1 Desenvolvimento da Página Web .................................................................. 62
4.1.2 Servidor HTTP ............................................................................................... 63
4.1.3 Configuração da Pilha TCP/IP ....................................................................... 65
4.1.4 Testes Desenvolvidos no Simulador .............................................................. 67
4.2 Desenvolvimento de Hardware ............................................................................ 70
5 FUNCIONAMENTO DO PROJETO PROPOSTO ...................................................... 74
5.1 Gravação da Página Web e da Pilha TCP/IP no Módulo ..................................... 74
5.2 Funcionamento da Aplicação Web Junto ao Microservidor .................................. 75
5.2.1 Funcionamento do Módulo Junto ao Sistema de Iluminação ......................... 78
6 CONCLUSÃO ............................................................................................................. 82
7 REFERÊNCIAS BIBLIOGRÁFICAS ........................................................................... 83
10
1 INTRODUÇÃO
Com o contínuo avanço da tecnologia e da automação envolvendo o setor
industrial, há sempre a necessidade de novas pesquisas e desenvolvimento de novas
técnicas. Dentre os inúmeros pontos a serem estudados e desenvolvidos dentro de um
processo, está o acionamento e monitoramento de sistemas ou máquinas, os quais
estão diretamente relacionados com a agilidade e qualidade da produção dentro de
uma fábrica ou a equipamentos usados no nosso dia-a-dia como condicionadores de
ar, sistemas de iluminação, equipamentos elétricos domésticos em geral e etc. Sendo
assim, o estudo e viabilização das novas tecnologias são indispensáveis não só para
os processos industriais, mas também nas áreas fundamentais para o bem estar
humano.
Atualmente existem alguns dispositivos de controle responsáveis pela parte de
comandos de sistemas ou equipamentos, Controladores Lógicos Programáveis - CLPs
por exemplo. Esse controlador pode acionar máquinas por métodos pré-definidos e
também monitorar as mesmas. O problema deste tipo de controle é que o investimento
da automatização é relativamente alto, o que, dependendo do processo se torna
economicamente inviável e, ainda há a necessidade da presença de um operador no
ambiente para iniciar o processo, saber em que estado ele se encontra e/ou para o
recolhimento dos dados de monitoramento.
Os sistemas de comunicação de dados, em especial a internet, vem se
tornando uma ferramenta cada vez mas essencial para o homem moderno,
aumentando significativamente a eficiência daqueles que utilizam seus recursos
(MOKARZEL, 2004).
De browsers web de telefones celulares a cafés que oferecem acesso sem fio à
internet, de redes domésticas com acesso a banda larga a infra-estruturas tradicionais
de TI (Tecnologia da Informação) em ambientes de trabalho com PCs (Computadores
11
Pessoais) interligados em rede, carros em rede, redes de sensores ambientais, internet
interplanetária - quando achamos que as redes de computadores já estão praticamente
presentes em toda parte, novas aplicações começam a ser desenvolvidas para ampliar
mais ainda o alcance das redes existentes hoje (KUROSE, 2006).
A enorme praticidade proporcionada pelo desenvolvimento atual das redes e da
internet, de em qualquer lugar que se tenha acesso a um navegador web, seja por
meio de um computador, um laptop, um PDA (Personal Digital Assistants - assistente
pessoal digital) ou mesmo pelo telefone celular, poder verificar o estado de um sistema
ou equipamento que se encontra geograficamente distante e, dali mesmo ter condições
de executar sua operação, é uma realidade possível de ser implementada, graças à
disposição das redes ethernets nos mais variados ambientes, complementada pela
possibilidade de fazer com que os dados adquiridos por um microcontrolador,
responsável pelo gerenciamento do processo, estejam disponíveis. Para isso, o
microcontrolador deverá conter um controlador ethernet embarcado, possibilitando-o
além da implementação da pilha de protocolos TCP/IP (conjunto de protocolos
organizados em camadas que regem o funcionamento da Internet onde os dois
principais são respectivamente o Transmission Control Protocol – Protocolo de
Controle de Transmissão / Internet Protocol – Protocolo de Internet) a conexão e
disponibilização dos dados na rede. Podendo assim ser considerado um microservidor
web.
Este trabalho apresenta a viabilidade técnica e econômica no desenvolvimento e
implementação de um módulo de pequeno porte, flexível, com um baixo consumo de
energia, baixo custo e baseado em um microcontrolador usado para controlar via rede
ethernet outros dispositivos elétricos remotamente através da internet. Será
demonstrado como exemplo prático, o controle de um sistema de iluminação, no qual o
usuário terá total controle sob o mesmo através do acesso à página, desde saber como
se encontra o estado das luzes (acesas ou apagadas), ou controlando tal estado
(acendendo/apagando), tendo ainda a opção de liberar ou não o sistema para ser
operado no próprio ambiente através dos interruptores.
Ao mesmo tempo, este trabalho envolve um grande desenvolvimento
científico/tecnológico, relacionando diretamente conceitos de: eletrônica,
microcontroladores, linguagens de programação, redes de comunicação e interfaces
web. Havendo assim, uma aplicação direta de conhecimentos adquiridos ao longo do
curso em casos práticos de automação.
12
1.1 Fundamentação Teórica
Atualmente, a internet se apresenta em contínuo avanço oferecendo a seus
usuários meios de obter e divulgar informações, com isso, a existência de um estudo
profundo na sua estrutura de conectividade, representa um importante fator de
desenvolvimento técnico-social.
É crescente também a realização de estudos para viabilidade de sistemas e
equipamentos inteligentes, que recebem esse nome por serem dotados de circuitos
eletrônicos com capacidade de processamento. A associação destes dispositivos com
a internet, já permitem a conectividade e o acesso a nível global de sistemas
eletrônicos e eletro-eletrônicos como dispositivos domésticos, industriais e etc.
A partir de conhecimentos básicos na área de comunicação industrial é fácil
perceber que a diferença entre as redes e os dispositivos conectados a elas vem
diminuindo. Pois, há um número crescente de dispositivos eletrônicos conectados em
rede independentemente de um computador ou servidor, e busca-se contar com
características tais como eficiência, economia, confiabilidade, segurança e
compatibilidade com os padrões internacionais de comunicação e topologias de redes
atuais, tornado-os compactos e funcionais.
Atentos a essas situações, muitos fabricantes tem direcionado investimentos
para a produção de sistemas embutidos com suporte a rede, área que está em franca
expansão, atualmente muitos deles direcionam suas tecnologias para plataformas de
sistemas embutidos, inclusive alguns deles com suporte para interface de rede (SILVA,
2002).
Com todas essas inovações, as atuais aplicações de acionamento e/ou
monitoramento remoto se tornaram mais simples e com um custo menor por não haver
mais a necessidade de um computador como servidor dedicado se comunicando com
uma placa de aquisição de dados, bastando agora, utilizar apenas uma placa dotada
de um microcontrolador com ethernet embutida.
A necessidade, em um primeiro momento, do uso de um computador como
servidor dedicado é justificado pelo mesmo ser responsável por conter as páginas web,
utilizada como interface de interação com a placa, o servidor web, responsável pelo
armazenamento e publicação das páginas na internet, o programa, responsável pelo
gerenciamento das ações no hardware dependendo da ação do usuário junto à página,
e também responsável pela comunicação placa/servidor.
13
A partir do momento que se utiliza a tecnologia da internet embarcada,
empregando microcontroladores com ethernet embutida, extingui-se a necessidade de
usar um computador como servidor, uma vez que, o servidor web, as páginas web e o
programa de aplicação estão armazenados no próprio dispositivo, a comunicação com
o computador servidor, naturalmente, não é mais necessário. Esse modelo possibilita
que monitoramento e acionamento possam ser realizados a partir de uma rede local ou
da Internet, utilizando um dispositivo dedicado e de baixo custo (SANTOS, 2009).
1.2 Arquitetura Proposta
O propósito final desse trabalho é a implementação de um módulo
microcontrolado capaz de se conectar a internet possibilitando o acionamento e
monitoramento de cargas via web, viabilizando, dentre outras aplicações possíveis, o
controle de um sistema de iluminação.
Figura 1.1 – Esquema de acesso de dados remotamente
A Figura 1.1ilustra o esquemático da implementação proposta. Foi utilizado no
projeto um microcontrolador da família PIC18F, este oferece, dentre outros recursos, a
possibilidade de conexão a internet. A particularidade dessa linha de
microcontroladores é que alguns modelos, como por exemplo, o PIC18F87J60,
possuem a capacidade de comunicar-se diretamente com a rede ethernet, motivo
principal que levou a escolha desse dispositivo para o projeto, enquanto outros, apesar
de serem capazes de implementar a pilha de protocolo TCP/IP, não tem a capacidade
14
de conexão direta a camada física da rede, sendo necessário um controlador ethernet
externo, como, por exemplo, o ENC28J60, também fornecido pela Microchip®. A
utilização desse controlador implica na necessidade da elaboração de circuitos de
tensão devidos a uma provável incompatibilização das tensões de trabalho entre o
controlador e o PIC, e, ainda, o uso de transformadores de isolamento entre o
controlador e a interface de rede, isso para o casamento das impedâncias e a proteção
elétrica do controlador ethernet.
A pilha TCP/IP utilizada neste projeto é a desenvolvida e fornecida
gratuitamente pela Microchip® e é similar a uma pilha TCP/IP tradicional. O objetivo da
mesma é permitir que um microcontrolador se conecte a internet como se fosse um
computador, a mesma é embarcada na memória não-volátil (Flash) do
microcontrolador, a fim de estabelecer a conexão lógica com uma máquina remota em
um determinado segmento de rede. O HTTP – Hypertext Transfer Protocol (Protocolo
de Transferência de Hipertexto), que pertence a camada de aplicação da pilha TCP/IP,
é responsável pela transferência de dados (texto, imagens ou sons) na internet. Dessa
forma, um navegador (Internet Explorer, Firefox, etc.), se comportando como cliente,
utiliza o HTTP para requisitar páginas web a um servidor (módulo embarcado)
conectado a uma rede local ou a internet.
O módulo microcontrolado, quando conectado a rede desenvolverá a função de
servidor web. A página contida neste microservidor precisará mostrar conteúdos
dinâmicos quando acessada, e interagir com o usuário quando ele fornecer entradas
através da própria página que por sua vez enviará uma informação para o
microservidor o qual retornará novos dados que deveram ser mostrados na página.
Essas variações de dados podem ser realizadas através do AJAX (Assyncronous
JavaScript And XML) que é uma técnica recente que usa um conjunto de tecnologias
padrões como o XML e o HTML dinâmico que usa HTML, CSS e JavaScript juntos.
O AJAX elimina a necessidade de se atualizar a página inteira a cada
requisição do usuário (como acontece no modelo web clássico). Com a comunicação
assíncrona, a transmissão de dados é mais eficiente, pois a atualização é feita somente
com os dados necessários. Dessa maneira há mais interatividade e rapidez (SILVA,
2009).
15
1.3 Objetivos
1.3.1 Geral
Este trabalho tem como objetivo o desenvolvimento de um módulo microservidor
para acionamento e monitoramento de cargas através de redes ethernet.
1.3.2 Específicos
• Utilizar a Internet para o monitoramento das variáveis envolvidas em um processo
e ainda como ferramenta de inserção de entradas para o acionamento remoto
de cargas;
• Adquirir conhecimentos sobre a tecnologia Internet Embarcada, que consiste
basicamente na conexão de sistemas embarcados à rede;
• Demonstrar, ao nosso público escolar, a importância e a viabilidade da utilização
dessa tecnologia, ainda pouco explorada, para o desenvolvimento de
automatizações no ambiente industrial;
• Melhorar as condições de trabalho do ser humano, por meio da eliminação do
contato direto para acionamento ou leitura de diagnósticos de equipamentos que
funcionam em ambientes perigosos ou insalubres;
• Desenvolver habilidades na utilização de softwares que possibilitam a construção
e simulação de circuitos eletrônicos e o desenvolvimento de programas que
comandam a seqüência de funcionamento de um hardware através de um
microcontrolador;
• Implementação de um software que promova o controle e a aquisição remota dos
dados do sistema via web em tempo real;
• Desenvolver testes do sistema proposto, primeiro com auxilio dos softwares de
simulação e logo depois no componente físico;
• Utilizar como exemplo de aplicação, o controle de um sistema de iluminação
através do módulo de acionamento e monitoramento via web.
1.4 Estrutura do Trabalho
O capítulo 1 apresenta um breve resumo sobre a importância dos dispositivos
embarcados com possibilidade de acesso a rede e das tecnologias e ferramentas
utilizadas nesse trabalho, assim como os objetivos que levaram o desenvolvimento do
mesmo.
16
O segundo capítulo faz uma revisão bibliográfica que abrange desde o
desenvolvimento das redes e da Internet, redes Ethernet, modelos de referência OSI
(Interconexão de Sistemas Abertos) e TCP/IP - comparando as duas tecnologias com
um resumo das funções das camadas que os constituem, até a utilização de
microcontroladores e sua aplicação com a tecnologia de Internet embarcada.
O capítulo 3 dispõe as ferramentas utilizadas para o desenvolvimento de software
e hardware.
O capítulo 4 traz a implementação do projeto, com a programação da página web
e adaptação da pilha TCP/IP da Microchip® à aplicação. É disposto também os
processos de compilação e simulação em software do projeto, assim como a
estruturação física do hardware relacionando os componentes utilizados para
montagem do mesmo.
O Capítulo 5 explica o funcionamento da aplicação web junto ao módulo
embarcado. Em seguida descreve o funcionamento do módulo controlando
remotamente (via Internet ou rede Ethernet local) um circuito de iluminação.
No capítulo 6 encontra-se a conclusão do trabalho e a sugestão para trabalhos
futuros.
17
2 REVISÃO BIBLIOGRÁFICA
Nesse capítulo estão apresentados alguns conceitos importantes para o
desenvolvimento do trabalho proposto, desde um breve resumo a cerca do
desenvolvimento das redes e da Internet, importância das redes Ethernets, modelos de
referência da pilha TCP/IP, fundamentos de microcontroladores e Internet embarcada.
2.1 Desenvolvimento das Redes de Comunicação e da I nternet
Uma rede é um conjunto de dispositivos interconectados capazes de enviar e\ou
receber informações entre eles, e surgiu exatamente da necessidade da troca de
informações, onde é possível ter acesso a um dado que está fisicamente localizado
distante de você. O desenvolvimento das redes de comunicação entre computadores
possibilitou o extraordinário sistema de comunicação existente hoje e que teve inicio à
cerca de quatro décadas.
Figura 2.1 – Modelo 360 IBM de 1964
18
Por volta dos anos 60 os sistemas computacionais eram altamente centralizados
e existiam poucas unidades de computadores, estes eram chamados de mainframes,
máquinas de grande porte, geralmente instalados em uma sala com paredes de vidro,
que pertenciam a grandes organizações de pesquisas e importantes universidades.
Esses computadores tinham capacidades de processamento isoladas, eram incapazes
de se comunicar com um outro computador. A Figura 2.1 mostra um modelo desses
computadores.
Segundo STEMMER (2010), nessa mesma época, na tentativa de melhorar a
interatividade usuário\computador surgiu uma técnica denominada time-sharing, que
consistia na conexão de um conjunto de terminais ao computador central através de
linhas de comunicação de baixa velocidade permitindo a um grande conjunto de
usuários o compartilhamento de um único computador para a resolução de grandes
quantidades e diversidades de problemas (cálculos complexos, ensino de
programação, aplicações militares, etc.). Esse aumento na demanda implicava na
necessidade crescente de atualizações e incrementos nas capacidades de
armazenamento e cálculos da unidade central, o que nem sempre era possível, pois
esses computadores do tipo mainframe geralmente não eram adaptados para suportar
determinadas extensões.
Interessada em encontrar um modo de compartilhar informações através de
computadores para agilizar o trabalho de seus pesquisadores, a Agencia de Projetos e
Pesquisas Avançadas (ARPA), do Departamento de Defesa dos Estados Unidos
(DoD), patrocinava grupos de pesquisadores para o desenvolvimento de uma rede de
comunicação capaz de sobreviver a uma guerra nuclear. Segundo FOROUZAN (2006)
em 1967, num encontro da Association Computing Machinery (ACM) o grupo ARPA
apresentou as idéias do projeto ARPANET, uma rede pequena de computadores. A
idéia era que cada computador (host), não importando o fabricante, pudesse se
comunicar a um computador específico, denominado IMP (interface message
processor – processadores de mensagens de interface). Os IMPs tinham a capacidade
de se conectar e se comunicarem entre si, assim como estabelecer comunicação com
o host que pedia acesso a rede.
Uma das estratégias da ARPA, que desenvolvia um conceito criado por Paul
Baran na Rand Corparation em 1960-4, foi criar um sistema de comunicação
invulnerável a ataques nucleares. Com base na tecnologia de comunicação de trocas
de pacotes, o sistema tornava a rede independente de centros de comandos e controle
19
(CASTELLS, 1999). Em 1969, seguindo o conceito de rede com controle
descentralizado com a possibilidade de envio de dados digitais em pequenos pacotes
que carregavam informações sobre o endereço dos dados, controle de erros e sobre o
seqüenciamento das informações, a ARPANET tornou-se uma realidade. Neste novo
cenário, cada computador conectado a rede era considerado um ponto, ou um nó,
mesmo que um dispositivo conectado ou parte do segmento da rede falhasse a parte
ainda operante rotearia os pacotes até o seu destino.
Esta primeira rede de computadores iniciou-se com quatro nós, a Universidade
da Califórnia em Los Angeles (UCLA), a Universidade Califórnia em Santa Bárbara
(UCSB), o Stanford Research Institute (SRI) e a Universidade da Utah. De acordo com
FOROUZAN (2006), um software batizado de Network Control Protocol (NCP)
controlou a comunicação entre os hosts, e segundo MORIMOTO (2009), eles eram
interligados por links de 50 Kbps, criados utilizando linhas telefônicas dedicadas,
adaptadas para o uso como links de dados. Essa velocidade em conexões de longa
distância era impressionante pra época onde as pessoas se dispunham de uma taxa de
110 bits por segundo com seus modems domésticos.
Esses quatro nós interligados, que se encontravam distantes uns dos outros, se
tratavam de quatro computadores de arquiteturas diferentes, formando uma rede que
tinha um propósito inicial de testes, mas, houve um crescimento tão grande que nos
primeiros anos da década de 70 já havia dezenas de computadores “pendurados”
nesta rede, interligando universidades, instituições militares e empresas. Cada nó era
conectado com pelo menos dois outros, o que garantia a operação da rede, pois
mesmo com a interrupção de varias conexões a mesma ainda continuaria funcionando.
Em meados de 1973, Vinton Cerf e Robert Kahn, cientistas da computação que
faziam pesquisas na ARPA, criaram a arquitetura fundamental da Internet
especificando um protocolo de transmissão que seria compatível com os pedidos de
vários pesquisadores e as diversas redes existentes (CASTELLS, 2009). Tratava-se do
estabelecimento do protocolo de controle de transmissão (Transmission Control
Protocol - TCP) que promovia a entrega segura de pacotes de dados em toda a rede.
Enquanto isso, várias organizações programavam suas próprias redes, tanto
para comunicação interna quanto para comunicação entre organizações, em pouco
tempo havia uma grande variedade de hardware e software de rede, gerando
problemas de compatibilização o que implicava um novo desafio: fazer com que
diferentes redes se interligassem. Por volta de 1978, Vinton Cerf, junto com outras
20
autoridades da área da computação, solucionaram esse problema dividindo o TCP em
duas partes, surgindo assim, o protocolo inter-redes (Internetworking Protocol - IP),
mais tarde denominado como Internet Protocol. O IP ficaria responsável por rotear as
informações entre as redes, enquanto o TCP assegurava que as mensagens fossem
corretamente enviadas de seu remetente até o destinatário. Assim, o TCP/IP
estabeleceu-se como um protocolo padrão, capaz de adaptar-se à diversidade, se
tornando a forma de comunicação mais comum entre computadores sendo a
arquitetura definitiva da ARPANET e mais tarde da Internet.
De acordo com CASTELLS (2009), ainda era necessário mais uma convergência
tecnológica para que os computadores se comunicassem: a adaptação do TCP/IP ao
UNIX, um sistema operacional que viabilizava o acesso de um computador a outro.
Esse sistema foi inventado pela Bell Laboratories em 1969, mas só passou a ser
amplamente usado depois de 1983, quando os pesquisadores de Berkeley (também
financiados pela ARPA) adaptaram o protocolo TCP/IP ao UNIX.
Paralelo ao desenvolvimento dessa rede universal de computadores custeada
pelo Pentágono, nos quais os estudos, em primeiro momento, eram restritos a grandes
universidades e renomados cientistas, existiam um grande número de intelectuais e
estudantes a procura de formas de transferir informações entre seus computadores. A
prova disso foi a invenção do modem, em 1978 por dois estudantes de Chicago. Ward
Chrisrensen e Randy Suess realizaram a descoberta quando buscavam uma forma de
transferir programas entre microcomputadores via telefone. Em 1979, divulgaram o
protocolo XModem, que permitia a transferência direta de arquivos, sem passar por um
sistema principal, entre as máquinas. Assim, as redes de computadores que não
pertenciam ao projeto ARPANET descobriam uma maneira de se comunicar.
O primeiro sistema amplamente utilizado de conversas on-line, a Usenet News,
surgiu a partir de uma versão modificada do protocolo UNIX o qual possibilitava a
interligação de computadores via linha telefônica comum. Esse sistema foi
desenvolvido em 1979 por três estudantes da Duke University e da Universidade da
Carolina do Norte, não inclusas na rede ARPANET.
Em fins da década de 1980, alguns milhões de usuários de computador já
estavam usando as comunicações computadorizadas em redes cooperativas ou
comerciais que não faziam parte da Internet. Em geral, essas redes usavam protocolos
que não eram compatíveis entre si, portanto adotaram protocolos da Internet, mudança
21
que na década de 1990, garantiu sua integração com a Internet e, assim, a expansão
da própria Internet (CASTELLS, 1999).
Apesar de todo o desenvolvimento já alcançado, a busca de informações através
da Internet ainda oferecia complicações, havia muitas dificuldades para localizar e
receber informações específicas e a capacidade de transmissão de gráficos, por
exemplo, ainda era muito limitada. Até então, as pesquisas e as trocas de informações
eram realizadas através do sistema Gopher, que utilizava o FTP – File Transfer
Protocol – para troca de arquivos. Como ele é baseado apenas em texto, tornava a
pesquisa e a leitura bastante tediosas.
Esses problemas foram solucionados a partir de um novo avanço tecnológico, o
desenvolvimento de um aplicativo denominado World Wide Web – WWW, a vasta teia
mundial, que facilitou o acesso a conteúdos na Internet através da organização do teor
das informações contidas na rede, agilizando as pesquisas e permitindo aos usuários
localizar e visualizar documentos baseados em multimídia – textos, animações,
imagens gráficas, áudios ou vídeos – sobre qualquer assunto, de maneira estruturada,
através da Internet. De acordo com DEITEL (2003), em 1990, Tim Berners-Lee, do
CERN (Conseil Européen pour la Recherche Nucléaire – Laboratório Europeu de
Pesquisa Nuclear) desenvolveu a World Wide Web e vários protocolos de comunicação
que foram o backbone, ou a espinha dorsal, da Web.
Segundo SAMPAIO (1996), a WWW foi criada inicialmente para facilitar a troca
de informações e descobertas entre a comunidade científica, mas rapidamente, com o
surgimento do navegador web Mosaic, de Mark Andressen, tomou conta de toda a
Internet. Informa ainda, que o grande truque da WWW é ser baseada em arquitetura
Cliente-Servidor, o que divide a responsabilidade do processamento entre o
computador do usuário e o do provedor de acesso. Isto permite que, enquanto um está
formatando os dados, o outro está transmitindo imagens e etc.
Ao novo sistema de organizar informações através da WWW, deu-se o nome de
‘hipertexto’. Berners Lee junto à equipe da CERN criaram um formato para esses
documentos de hipertexto, a linguagem de marcação de hipertexto – HTML,
acrescentando essa formatação ao protocolo TCP/IP e configurando um novo protocolo
de transferência de hipertexto – HTTP, para orientar a comunicação entre navegador e
servidor.
Em fevereiro de 1990, a ARPANET, ainda sustentada pelo Departamento de
Defesa dos Estados Unidos e operada pela Fundação Nacional de Ciência, encerrava
22
suas atividades passando a responsabilidade de “espinha dorsal da Internet” para
NSFNET também operada pela National Science Foundation, que operou até abril de
1995, quando o governo anunciou a privatização da Internet. Fato, provavelmente
provocado, por fortes pressões comerciais e pelo grande aumento de usuários com o
crescimento das redes de empresas privadas e de redes corporativas sem fins
lucrativos.
A partir de então, surgiram varias empresas denominadas ISPs (Internet Service
Providers - provedores de serviços da Internet), que ofereciam a usuários comuns de
computadores a possibilidade de conexão de suas máquinas à Internet, e o mundo
todo a abraçou criando uma verdadeira teia mundial.
Desde a década de 1960 a Internet sofreu muitas mudanças. Hoje ela é uma
grande rede TCP/IP constituída de milhões de pequenas redes trabalhando juntas. O
seu poder de comunicação, juntamente com os progressos em telecomunicações, na
computação e no desenvolvimento de dispositivos eletrônicos provocou grandes
mudanças no mundo tecnológico.
2.2 Surgimento do Padrão Ethernet
No decorrer da década de 1970, paralelo ao desenvolvimento das redes de
comunicação entre computadores geograficamente distribuídos que fundamentaram a
Internet, desenvolvia-se uma rede de transmissão de dados entre micros que se
encontravam em um mesmo ambiente. De acordo com MORIMOTO (2009), o primeiro
teste foi feito em 1973 dentro da PARC (laboratório de desenvolvimento da Xerox, em
Palo Alto, EUA). O teste deu origem a primeira rede Ethernet, que transmitia dados a
2.94 megabits através de cabos coaxiais. Até 256 estações de trabalho podiam ser
conectadas ao sistema por meio de transceptores presos ao cabo.
O nome Ethernet não foi escolhido por acaso para denominar tal forma de
transmissão de dados. De acordo com TANENBAUM (2003), o termo “ether”, vem do
éter luminífero - meio pelo qual os físicos do século XIX acreditavam que a radiação
eletromagnética se propagava. O termo foi escolhido para enfatizar que o padrão
Ethernet não era depende do meio, ou seja, ele podia ser adaptado para transmitir
dados através de um cabo coaxial, cabos de fibra ótica e até mesmo pelo ar, no caso
das redes wireless.
A tecnologia Ethernet continuou se desenvolvendo, sua taxa de transmissão logo
passou de 2.94 Mbps para 10Mbps, quando foi adotada pela IEEE (Institute of Eletrical
23
and Eletronics Engineers) como padrão 802.3, segundo LOPEZ (2000) em 1988.
Caracterizou-se como padrão de rede de uso geral, dando origem às importantes redes
locais ou LANs (Local Area Network). Esse estilo de rede passou a ser amplamente
utilizado para interconectar computadores pessoais em áreas geograficamente
pequenas, como uma empresa, ou uma universidade, possibilitando o
compartilhamento de equipamentos, como impressoras, o que permite melhor
aproveitamento de recursos disponíveis em ambientes de trabalho. Outra vantagem é
que a rede local era a forma mais barata de conectar todos os micros a Internet, se
comparada à forma existente na época onde cada micro tinha por obrigação uma linha
telefônica e um modem.
A primeira implementação do padrão Ethernet 10 Mbps, denominava-se 10BASE-
5, sigla que é a junção de 3 informações. O “10” se refere a velocidade de transmissão,
10Mbps, o “BASE” é abreviação de “baseband modulation”, o que indica que o sinal é
transmitido diretamente, de forma digital (sem o uso de modems, como no sistema
telefônico), enquanto o “5” indica a distancia máxima que o sinal é capaz de percorrer,
nada menos que 500 metros (MORIMOTO, 2009). Essas redes utilizavam cabos
thicknet, um tipo de cabo coaxial grosso e pouco flexível e eram montadas na topologia
física em barramento, como mostra a Figura 2.2.
Figura 2.2 – Estações conectadas ao meio usando pad rão 10Base5.
Logo depois, outras três implementações do Ethernet padrão (10Mbps)
surgiram. A rede 10Base5 logo deu lugar á 10Base2, que apesar de também utilizar
topologia de rede em barramento, possuía cabos coaxiais bem mais finos, que
facilitavam o manuseio, sua distancia máxima de transmissão é de 200 metros. A
terceira implementação é a 10BaseT, Figura 2.3, que utiliza um hub - repetidor
multiportas, para estabelecer conexão física entre estações formando uma topologia
24
em estrela, e cabos de par trançado, bem mais finos e flexíveis se comparados aos
coaxiais. Este padrão ainda é muito utilizado hoje em dia.
Figura 2.3 – Estações conectadas ao meio usando pad rão 10BaseT.
A quarta implementação foi a 10BaseFL, que utiliza topologia estrela para
conectar as estações a um hub, e cabos de fibra óptica para transmissão de dados.
Desde então surgiram novos padrões com velocidades de transmissão maiores como
Fast Ethernet – de 100 Mbps, e o Gigabit Ethernet – de 1000 Mbps. Logicamente os
sistemas de cabeamento foram sucessivamente aprimorados.
O Fast Ethernet é composto por três padrões distintos: o 100BaseTX utiliza
cabos de par trançado categoria 5, segundo MORIMOTO (2009) utilizado em mais de
80% das instalações atuais. Nesse protocolo foi mantida a distância máxima de 100
metros, mais foi adicionado o modo full-duplex, onde as estações podem enviar e
receber dados simultaneamente (100 megabits em cada direção), desde que seja
usando um switch. O 100BaseT4 com cabos de categoria 3, foi pouco utilizado, de
forma que muitas placas de rede sequer oferecem suporte a ele. Por fim, o 100BaseFX
com cabo de fibra óptica que possibilitava criar links com cabos de até 2 km e com
possibilidade de atingir distâncias maiores através de repetidores.
Por sua vez, o Gigabit Ethernet é composto por quatro padrões diferentes:
1000BaseLX, suporta apenas fibra óptica e usa uma tecnologia com uso de lasers ao
invés de LEDs, como em outros transmissores de rede para fibra óptica, tornando-a
mais cara, em compensação seu alcance pode chegar a 10 km. 1000baseSX também
utiliza fibra óptica, mas com uma tecnologia de transmissão derivada da usada em CD-
ROMs, que torna o custo mais baixo. O alcance máximo atingido nesse padrão é 500
metros. 1000BaseCX, utiliza dois pares de cabo de par trançado blindado, mas seu
25
alcance atinge apenas 25 metros. Por fim, o padrão 1000BaseT, que permite usar o
cabo de par trançado categoria 5, representando grande economia. Seu alcance
continua sendo de 100 metros e os switches compatíveis com o padrão são capazes
de combinar nós de 10, 100 e 1000 megabits sem que os mais lentos atrapalhem os
demais. Os três padrões para cabos de par trançado, 10BaseT, 100BaseTX e
1000BaseT, caracterizam-se como os mais importantes entre os padrões Ethernet
cabeados, e são os mais utilizados no nosso dia-a-dia.
Tradicionalmente, as redes Ethernet operam em modo half-duplex, onde é
possível realizar apenas uma transmissão por vez, enviando ou recebendo dados, mas
não as duas coisas simultaneamente. Este modo de funcionamento é herança das
redes 10Base2 e das redes com hubs burros, onde todas as estações são ligadas ao
mesmo cabo e apenas uma pode transmitir de cada vez, com possibilidade de
ocorrerem colisões (MORIMOTO, 2009).
Quando os dispositivos são interligados numa rede através de um meio em
comum, como um cabo longo funcionando como uma espinha dorsal por onde
circularão dados de todas as estações conectadas a ela, (topologia em barramento),
caracterizando conexões multiponto, é necessário a existência de um protocolo que
controle o acesso das estações ao meio.
No sistema de transmissão de dados da rede Ethernet padrão de (10 Mbps), o
método de acesso ao meio adotado foi o CSMA/CD (Carrier Sense Multiple Access
with Collision Detection) que se trata de um protocolo de acesso múltiplo com vigilância
de portador Carrier Sense e detecção de colisão. Com o uso deste, qualquer estação
pode ter acesso ao cabo em qualquer momento, não há prioridade entre as máquinas.
Antes de um dos computadores iniciar uma transmissão, inspeciona o cabo para saber
se alguém mais já esta transmitindo, em caso afirmativo, ele espera até que o cabo
esteja livre para então iniciar sua transmissão, evitando interferências. Caso, dois ou
mais micros iniciem a transmitir ao mesmo tempo ocorrerá uma colisão de dados e
todos eles param de transmitir, esperam um período de tempo aleatório e tentam a
retransmissão. Se ocorrer uma nova colisão, o tempo aleatório de espera é duplicado e
as tentativas de transmissão continuam até que uma das estações consiga iniciar sua
transmissão ou até que seja excedido o valor limite de tentativas, o que significa que a
estação tentou o suficiente e deve desistir de tentar.
De acordo com FOROUZAN (2006), o CSMA/CD, utiliza o exponential backoff
method – método de espera exponencial, onde a estação espera durante um intervalo
26
de tempo entre 0 e 2N ×tempo de propagação máxima (tempo de propagação entre as
duas estações mais distantes da rede), onde N é o número de tentativas de
transmissão. Noutras palavras a estação irá esperar entre 0 e [2 × (tempo de
propagação máxima)] após a primeira colisão, entre 0 e [22× (tempo de propagação
máxima)] após a segunda colisão e assim por diante. O valor limite de N é tipicamente
15.
Hoje em dia, “Ethernet” é quase sinônimo de rede. Por ser um padrão aberto,
qualquer fabricante pode fabricar placas e outros componentes de rede e desenvolver
soluções, o que aumenta a concorrência e o volume produzido, derrubando os preços.
Dentro do cenário atual, desenvolver padrões proprietários de rede não faz muito
sentido, pois além de produzir as placas o fabricante precisaria arcar com todos os
custos relacionados ao desenvolvimento e à divulgação da tecnologia (MORIMOTO,
2009).
Entre muitas vantagens estão à facilidade de montar, de gerenciar, manter, a
capacidade de interconectividade e acesso remoto. Por tudo isso a Ethernet é a
tecnologia de rede local (LAN) mais popular e mais utilizada no mundo em aplicações
de rede de comunicação comercial, e mais recentemente em aplicações industriais. Ela
se encontra disposta nos mais variados ambientes sejam eles educacionais, públicos,
residenciais, comerciais, industriais, etc. Deve ser lembrado que as redes Ethernet
possuem a importante característica de conexão a Internet.
Atentos as novas tendências, muitos fabricantes têm dedicado esforços no
desenvolvimento de equipamentos, das mais variadas aplicações, com suporte a rede,
e em alguns casos, já são desenvolvidos com a tecnologia Ethernet embarcada em sua
estrutura física.
De acordo com ALBUQUERQUE (2009), nos últimos anos é crescente o
interesse da indústria pela rede Ethernet como uma possível alternativa no chão de
fábrica e no controle de processos.
As redes industriais de chão de fábrica, fieldbus, surgiram para substituir o
sistema até então existente na indústria, conhecido como sistema centralizado ou
ponto-a-ponto e com o surgimento dos instrumentos digitais era necessário algo que
pudesse interligá-los. O sistema tradicional, existente ainda em muitas indústrias, é
formado basicamente por CLPs com suas entradas e saídas ligadas a diversos
hardwares espalhados na fábrica, o que implica em inúmeros cabos, muitas vezes de
grande comprimento e na dificuldade de encontrar e diagnosticar defeitos na planta
27
industrial. Com a implementação da rede, um único cabo interliga os elementos de
campo.
Essas redes proporcionam, menor custo nas implementações devido à menor
quantidade de cabos necessária, maior organização nas montagens, ganho de tempo
em relação ao encontro e resolução de defeitos no sistema, maior flexibilidade ao
processo de controle industrial, permitindo expansões futuras entre outras vantagens.
Nesse contexto de custo/benefício, vários protocolos de chão de fábrica foram
desenvolvidos e bastante difundidos, como exemplo, PROFIBUS, Devicenet, Fieldbus
Foundation, Modbus, AS-I, e outros. A escolha por utilizar uma destas redes depende
da preferência e do conhecimento dos gestores das redes em cada fábrica ou mesmo
pela aplicação. O problema é que essas fieldbuses, por serem de fabricantes
diferentes, são baseadas em protocolos distintos, tornando os sistemas proprietários e
caros. A partir daí, surgiu a necessidade da padronização entre essas redes, e a forma
mais difundida para isso era com o padrão TCP/IP, então, essas redes foram
adaptadas à tecnologia Ethernet, dando origem a Ethernet industrial.
O padrão TCP/IP surgiu no meio industrial há cerca de oito anos, porém apenas
nos últimos quatro anos é que se tornou comercialmente utilizado em ambientes
industriais (LUGLI, 2010).
2.3 Modelo de Referência OSI (MR-OSI)
A grande importância da interconexão dos computadores através de redes de
comunicação deu origem a uma necessidade que foi tornando-se evidente à medida
que os desenvolvimentos nesse domínio foram acentuando-se: a padronização das
redes de comunicação (STEMMER, 2010).
Estabelecida em 1947, a International Organization for Standardization (ISO) é
um corpo multinacional de pesquisadores/projetistas dedicado à criação de padrões
internacionais. Um padrão ISO que cobre todos os aspectos relacionados às redes de
comunicação é o modelo Open Systems Interconnection (OSI). Esse modelo foi
apresentado no final da década de 70. Um sistema aberto (open system) é um
conjunto de protocolos que permite a dois sistemas quaisquer se comunicarem não
importando as arquiteturas em que eles estão baseados. O propósito do modelo OSI é
mostrar como implementar comunicação entre dois sistemas sem requerer
modificações lógicas tanto do ponto de vista do hardware quanto do software. O
modelo OSI não é um protocolo; ele é um modelo que auxilia na compreensão e
28
projeto de novas arquiteturas de rede que sejam ao mesmo tempo flexíveis, robustas e
interoperáveis (FOROUZAN, 2006).
O modelo OSI foi desenvolvido seguindo a filosofia das arquiteturas
multicamadas.
Os projetistas de rede decidiram organizar os protocolos em camadas devido a
uma série de vantagens conceituais e estruturais. Uma das vantagens, por exemplo, é
que a modularidade facilita a atualização de componentes do sistema. Desta forma,
cada protocolo pertence a uma das camadas e oferece serviços para as camadas
adjacentes. Uma camada de protocolo pode ser implementada em software, em
hardware ou em uma combinação entre os dois (KUROSE, 2006).
Figura 2.4 – Camadas do modelo de protocolos OSI.
A Figura 2.4 mostra as sete camadas definidas para o modelo, cujos princípios
de definição, segundo STEMMER (2010), foram os seguintes:
• Cada camada corresponde a um nível de abstração necessário no modelo;
• Cada camada possui suas funções próprias e bem definidas, e foram escolhidas
segundo a definição dos protocolos normalizados internacionalmente;
• A escolha das fronteiras entre as camadas deveria ser definida de modo a
minimizar o fluxo de informação nas interfaces;
• O número de camadas deveria ser suficiente grande para evitar a realização de
funções muito diversas por uma mesma camada, e, suficientemente pequeno
para evitar uma alta complexidade da arquitetura.
29
Levando em consideração a transmissão de um dado, cada camada recebe as
informações passada pela camada superior, acrescenta informações de sua
responsabilidade e repassa os dados para a camada imediatamente inferior, esse
processo é denominado encapsulamento. Quando as informações chegam à camada
de Transporte, os dados são divididos em pacotes (conjunto de dados manipulados nas
camadas 3 e 4 que carregam informações de endereçamento virtual, como o IP da
máquina de destino), os quais serão novamente divididos, agora em vários quadros
(conjunto de dados enviados na rede, associados as camadas 1 e 2, os quadros
carregam informações de endereçamento físico, como o endereço real de uma placa
de rede) na camada de Enlace. Esse processo é invertido na recepção de um dado.
Figura 2.5 – Funcionamento da comunicação entre as camadas do modelo OSI.
A forma de comunicação de dados entre as camadas do modelo de referência
RM-OSI é ilustrada na Figura 2.5. Neste caso, um aplicativo emissor está transmitindo
dados a um aplicativo receptor. Tudo se inicia com o envio de dados do emissor,
através de um protocolo de comunicação, à camada de aplicação que acrescenta
informações de sua competência, um cabeçalho de aplicação, 7, e envia a mensagem
resultante à camada de apresentação que, por sua vez, introduz a mensagem recebida
o cabeçalho de apresentação, 6. Esse processo continua até a camada física, quando
os dados que agora estão na forma de quadros, são enviados pelo cabeamento de
rede chegando até a camada física do aplicativo receptor.
30
Uma vez no receptor, os diversos cabeçalhos introduzidos por cada uma das
camadas de rede do emissor vão sendo interpretadas e eliminadas nas camadas
correspondentes do sistema destino até que dados cheguem ao aplicativo emissor.
Nas redes baseadas em arquitetura multicamadas, durante o processamento de
um dado, que vai passando em cada camada, uma determinada camada não toma
conhecimento da existência e significado das informações de cabeçalho introduzidas
por outra camada, considerando este como parte dos dados que compõem a
mensagem. De acordo com STEMMER (2010), o conceito fundamental da
transferência de dados é que cada camada foi projetada como se a comunicação fosse
realmente horizontal quando na verdade a transmissão se dá de modo vertical.
A comunicação vista na Figura 2.5 é um exemplo de como realmente acontece a
transmissão de um dado através de uma rede, denominada comunicação real. Como já
informado, as camadas foram desenvolvidas como se a transmissão ocorresse de
forma horizontal, ou seja, a comunicação ocorreria entre as diferentes camadas pares
(camadas localizadas em sistemas diferentes, mas associadas a um mesmo nível).
Nesse sentido, uma determinada camada do emissor comunica-se com a mesma
camada do dispositivo receptor. Essa comunicação, denominada virtual, é ilustrada na
Figura 2.6.
Figura 2.6 – Comunicação virtual no modelo OSI.
As camadas do modelo OSI podem ser divididas em três grupos: aplicação,
transporte e rede, como ilustrado na Figura 2.7. As camadas de rede se preocupam
com a transmissão e recepção dos dados através da rede e, portanto, são camadas de
baixo nível. A camada de transporte é responsável por pegar os dados recebidos pela
31
rede e repassá-los para as camadas de aplicação de uma forma compreensível, isto é,
ela pega os pacotes de dados e transforma-os em dados quase prontos para serem
usados pela aplicação. As camadas de aplicação, que são camadas de alto nível,
colocam o dado recebido em um padrão que seja compreensível pelo programa
(aplicação) que fará uso desse dado.
Figura 2.7 – Grupos das camadas do modelo OSI.
A seguir, encontra-se um resumo de informações sobre as funções de cada uma
das camadas, segundo TANENBAUM (2003), do modelo de referencia RM-OSI.
• Camada Física - responsável pela transmissão de uma cadeia de bits num
determinado meio físico. Deve tratar de todas as especificações físicas do meio
de transmissão, como: características elétricas (níveis de tensão a serem
usados para representar um bit 1 e um bit 0), mecânicas (tipo de cabeamento;
número de pinos no conector de rede), taxa de transmissão (número de bits
enviados por segundo), a forma como a conexão inicial será estabelecida e de
que maneira ela será encerrada quando os dois lados tiverem terminado de
transmitir.
• Camada de Enlace de dados – sua tarefa é transformar os grupos de dados
brutos provenientes da camada física em uma linha que pareça livres de erros
(link confiável), para a camada de rede. Ela também controla o fluxo de dados
impedindo que um transmissor rápido envie uma quantidade excessiva de dados
a um receptor lento. Com frequência, é necessário um mecanismo que regule o
tráfego para informar ao transmissor quanto espaço o buffer do receptor tem no
momento.
32
• Camada de Rede – responsável pelo roteamento de pacotes da origem até o
destino, possivelmente viajando entre inúmeras redes, permitindo que redes
heterogêneas sejam interconectadas.
• Camada de Transporte – garante que as mensagens sejam entregues intactas e
livres de erros. Essa camada utiliza um método de fragmentação e
reagrupamento de pacotes, na transmissão e recepção respectivamente, para
evitar que uma mensagem monopolize o link ou o segmento de rede pelo qual
trafega. Ao receber dados da camada acima, divide estes em vários segmentos
de tamanhos variados, onde cada um possui um número de identificação,
repassa essas unidades à camada de rede e assegura que todos os fragmentos
cheguem corretamente a outra extremidade. O número de identificação de cada
fragmento permite que a camada de transporte do sistema receptor remonte e
identifique se a mensagem se encontra realmente intacta.
• Camada de Sessão – camada que oferece serviços como o controle de diálogo –
permitindo que dois dispositivos iniciem um dialogo e controlando quem deve
transmitir em cada momento. Sincronização – adicionando pontos de
verificação, realizando uma verificação periódica em transmissões longas
permitindo que, em caso de falhas, elas continuem do ponto onde estavam.
• Camada de Apresentação – está relacionada á sintaxe e a semântica das
informações transmitidas. Diferentes computadores utilizam diferentes sistemas
de codificação das informações trocadas, a camada de apresentação é
responsável pela interoperabilidade entre os diferentes métodos de codificação.
Segundo FOROUZAN (2006), a camada de apresentação no transmissor
converte a informação expressa no seu formato próprio numa informação em um
formato comum (universal). A camada de apresentação no receptor converte a
informação nesse formato universal para o formato adequado ao receptor.
• Camada de Aplicação – é o nível mais alto dentre as camadas. Permite aos
usuários acesso à rede por conter diversos protocolos de aplicação como, por
exemplo, o Protocolo de Transferência de Hiper Texto - HTTP, que constitui a
base para a WWW. Quando um navegador deseja uma página Web, ele envia o
nome da página desejada ao servidor, utilizando HTTP.
Segundo TANENBAUM (2003), existem vários motivos que levaram aos
protocolos associados ao modelo OSI serem raramente usados nos dias de hoje. Entre
eles, a tecnologia utilizada era considerada ruim, pois, existem falhas no modelo e nos
33
protocolos. Revela que a escolha das sete camadas foi mais política de que técnica.
Enquanto duas das camadas (de sessão e apresentação) estão praticamente vazias,
duas outras (enlace de dados e rede) se encontram sobrecarregadas. A arquitetura é
muito complexa o que dificulta a implementação enquanto sua operação não é nada
eficiente, pois, devido a essa enorme complexidade do modelo e dos protocolos as
implementações iniciais eram lentas, pesadas e gigantescas.
2.4 Pilha de Protocolos TCP/IP – Arquitetura da Int ernet
A pilha TCP/IP, como já mencionado no texto acima, é um conjunto de protocolos
de comunicação entre computadores em rede. Seu nome vem dos protocolos TCP e
IP, que são à base da arquitetura da Internet, e foram desenvolvidos bem antes da
definição do modelo de referencia OSI. Embora também possa ser visto como modelo
desenvolvido em camadas onde cada uma é responsável por um grupo de tarefas, as
camadas no modelo da Internet não casam exatamente com as camadas do modelo
OSI. O modelo de referencia TCP/IP, como demonstra a Figura 2.8, é constituído de
quatro camadas, enquanto o modelo OSI possui sete.
Figura 2.8 – Comparação estrutural em relação às ca madas entre os modelos de referencia OSI e TCP/IP.
Enxergar as camadas como fornecedores ou consumidores de serviço é um
método de abstração para isolar protocolos de camadas acima dos pequenos detalhes
de transmitir bits através, digamos, de ethernet, e a detecção de colisão enquanto as
camadas abaixo evitam ter de conhecer os detalhes de todas as aplicações e seus
protocolos (WIKIPÉDIA, 29/02/2012).
34
Como pode ser facilmente observado na figura 2.8, geralmente, as três camadas
mais acima do modelo OSI (aplicação, apresentação e sessão) são consideradas como
uma única camada (aplicação) no modelo TCP/IP. Isso porque o TCP/IP tem uma
camada de sessão relativamente leve, consistindo de abrir e fechar conexões sobre
TCP e RTP - Real-time Transport Protocol (transporte) e fornecer diferentes números
de portas para diferentes aplicações sobre TCP e UDP - User Datagram Protocol. Se
necessário, essas funções podem ser aumentadas por aplicações individuais (ou
bibliotecas usadas por essas aplicações).
Vejamos um breve resumo das funções reservadas a cada camada no modelo de
referencia TCP/IP:
• Camada de Aplicação – (referente às camadas 5 à 7 da OSI). Camada que a
maioria dos programas de rede usa para se comunicar através da rede. A
camada define os protocolos de aplicativos TCP/IP que provém serviços que
suportam diretamente aplicações do usuário. Dentre as aplicações estão a
possibilidade de transferência de arquivos, busca de páginas na web, envio de
emails e etc. O pacote relacionado à camada de aplicação é chamado
Mensagem ou Dados .
• Camada de Transporte – (referente a camada 4 da OSI). Onde é determinado
para qual aplicação um dado qualquer é destinado. Camada responsável pela
garantia da entrega de dados e da integridade dos mesmos. Entre os protocolos
existentes nessa camada os dois mais importantes e mais utilizados são o TCP
e o UDP. O TCP (Transmission Control Protocol – protocolo de controle de
transmissão) é um mecanismo de transporte confiável orientado a conexão que
garante a entrega de dados ao receptor sem erros e na ordem que foram
enviados, controla ainda o fluxo de dados enviados (desacelerando se
necessário evitando uma sobrecarga na rede). Já o UDP (User Datagram
Protocol – protocolo de datagrama do usuário) é um protocolo sem conexão e
não confiável, pois ele não oferece qualquer garantia se os dados alcançaram
seu destino ou se chegaram na ordem de envio. Este protocolo é utilizado em
uma aplicação em que a entrega imediata é mais importante que a garantia de
entrega, como a transmissão de voz e vídeo. O pacote da camada de transporte
é chamado Segmento .
• Camada de Internet – (referente à camada 3 da OSI). A tarefa dessa camada é
entregar pacotes IP onde for necessário. Ou seja, ela permite que os hosts
35
injetem pacotes em qualquer rede e deve garantir que eles trafeguem
independentemente até o destino (talvez em uma rede diferente) (TANENBAUM,
2003). O IP (Internet Protocol – protocolo da Internet) foi projetado para não ser
confiável, por isso os pacotes podem chegar ao seu destino em ordem
diferentes as que foram enviadas. De acordo com informações colhidas na
WIKIPÉDIA (29/02/2012), o protocolo IP pode transmitir dados para diferentes
protocolos de níveis mais altos, esses protocolos são identificados por um único
número de protocolo IP , alguns destes, como o ICMP - Internet Control
Message Protocol – protocolo de controle de mensagens (usado para transmitir
informação de diagnóstico sobre a transmissão IP) e o IGMP - Internet Group
Management Protocol – protocolo de gerenciamento de grupo (usado para
gerenciar dados multicast) são colocados acima do IP mas executam funções da
camada internet. Isso ilustra uma incompatibilidade entre os modelos da internet
e OSI.
• Camada de Rede – (referente ás camadas 1 e 2 do modelo OSI). Essa camada
tem a responsabilidade de detalhar o modo como os dados serão enviados
fisicamente pela rede, trata das características elétricas e mecânicas do meio,
como tipos de conectores e cabos utilizado para estabelecer uma comunicação.
Como pode ser observado na Figura 2.8, e informado na WIKIPÉDIA
(29/02/2012), a camada de enlace de dados não é realmente parte do modelo
TCP/IP, mas é o método usado para passar quadros da camada de internet de
um dispositivo para a camada de internet de outro. Esse processo pode ser
controlado tanto em software (device driver) para a placa de rede quanto em
firmware ou chipsets especializados. Esses irão executar as funções da camada
de enlace de dados como adicionar um header (cabeçalho) de pacote para
prepará-lo para transmissão, então de fato transmitir o quadro através da
camada física. Do outro lado, a camada de enlace irá receber quadros de dados,
retirar os headers adicionados e encaminhar os pacotes recebidos para a
camada de internet.
36
Tabela 1 – Relação de protocolos da pilha TCP/IP.
Camadas Protocolos
1 Aplicação HTTP, SMTP, FTP, SSH, Telnet, SIP, RDP, IRC, SNMP,
NNTP, POP3, IMAP, BitTorrent, DNS, Ping ...
2 Transporte TCP, UDP, RTP, SCTP, DCCP ...
3 Internet IP (IPv4, IPv6) , ARP, RARP, ICMP, IPsec ...
4 Interface de
Rede
Ethernet, Token Ring, X.25, RS-232...
Os principais protocolos relacionados a cada uma das camadas do modelo
TCP/IP estão apresentados na Tabela 1.
De acordo com TANENBAUM (2003), a baixo da camada de internet, encontra-se
um grande vácuo. O modelo de referencia TCP/IP não especifica muito bem o que
ocorre ali, exceto o fato de que o host tem de se conectar à rede utilizando algum
protocolo para que seja possível enviar pacotes IP. A camada de rede, nesse modelo
de 4 camadas, não se caracteriza como uma camada no sentido em que o termo é
usado no contexto de protocolos hierarquizados. Trata-se na verdade de uma interface
(entre as camadas de rede e de enlace de dados), ou seja, o modelo não faz distinção
(nem se quer menciona) diferenças entre as camadas físicas e enlace de dados, as
quais tem funções bastante diferenciadas. A camada física, esta relacionada às
características físicas da transmissão dos bits, enquanto, a camada de enlace de
dados é delimitar o início e o final dos quadros e enviá-los de um lado a outro com o
grau de confiabilidade desejado.
Por tudo, são várias as bibliografias encontradas que substituem modelo inicial
do TCP/IP baseado em 4 níveis: Host/rede; Inter-rede; Transporte; e Aplicação. E
trabalham com um modelo híbrido, com 5 camadas, que retira o excesso do modelo
OSI e melhora o modelo TCP/IP: Física; Enlace; Internet; Transporte; e Aplicação.
Hoje, a maioria dos sistemas operacionais comerciais incluem e instalam a pilha
TCP/IP por padrão. Para a maioria dos usuários, não há nenhuma necessidade de
procurar por implementações. O TCP/IP é incluído em todas as versões do Unix e
Linux, assim como no Mac OS e no Microsoft Windows (WIKIPÉDIA, 29/02/2012).
37
2.5 Microcontroladores
Este tópico faz uma breve introdução sobre microcontroladores, em especial os
da linha PIC fabricados pela Microchip®, que são largamente utilizados em aplicações
didáticas, embarcados em equipamentos eletroeletrônicos, em ambientes industriais,
comerciais, residenciais e etc.
Em meados da década de 1980, vários componentes externos foram integrados
em um mesmo chip, o que resultou em circuitos integrados chamados
microcontroladores e na difusão dos sistemas embarcados (WIKIPÉDIA, 02/03/2012).
Pode-se dizer que a função básica de um microcontrolador é processar
informações a partir de sinais de entrada, provenientes de um botão ou um sensor por
exemplo. Com o resultado de todo processamento, o dispositivo libera sinais de saída
que ativarão outros dispositivos. Nesse sentido, são dispositivos destinados a sistemas
dedicados a tarefas específicas, assim os mesmos podem possuir tamanho, recursos
computacionais e custo reduzidos se comparados a computadores normais.
Para que esses componentes sejam capazes de desenvolver todo esse
gerenciamento lógico, é necessário que informações (informando-o o que deve
acontecer quando determinados eventos ocorrerem) sejam estruturadas na forma de
um programa e gravada dentro do dispositivo. Esse programa será executado sempre
que o microcontrolador for energizado.
Uma definição bastante clara desses componentes é feito por MIYADAIRA
(2011), que informa que os microcontroladores (µC ou MCU) são pequenos
dispositivos dotados de “inteligência”, basicamente constituídos de CPU (Central
Processing Unit – Unidade Central de Processamento), memória (dados e programas)
e periféricos (portas E/S (Entrada/Saída), I2C, SPI, USART etc.). Suas dimensões
reduzidas são resultantes da alta capacidade de integração, em que milhões de
componentes são inseridos em uma pastilha de silício pela técnica de circuitos
integrados (CI’s). Eles estão presentes na maioria dos equipamentos digitais, como
celulares, MP3 player, impressoras, robótica, instrumentação, entre outros.
Quanto à “inteligência” do componente, podemos associá-la à Unidade Lógica
Aritmética (ULA), pois é nessa unidade que todas as operações matemáticas e lógicas
são executadas. Quanto mais poderosa a ULA do componente, maior sua capacidade
de processar informações (SOUZA, 2007).
Como se vê, um microcontrolador é dotado de recursos suficientes – que
permitem sua utilização em diversas aplicações – dentro do chip. Nesse aspecto o
38
MCU oferece vantagens sob os microprocessadores, onde para a utilização dos
mesmos se faz necessário o uso de memória externa e dispositivos de E/S, em contra
partida, esses são dispositivos com funções dedicadas a CPU oferecendo grande
poder de processamento e velocidade de execução, utilizados em aplicações
complexas e de alto desempenho onde não existem restrições em relação a custo e
dimensões físicas do componente.
Além de toda performance, de poderem ser utilizados em diversos projetos
eletroeletrônicos oferecendo agilidade e controle, os µC’s ainda trazem a característica
de baixo consumo de energia, sem falar que geralmente possuem a habilidade de
entrar em modo sleep (modo de espera onde a CPU e os periféricos são desligados),
passando a ter um consumo ainda mais baixo. O µC retorna a seu estado normal a
partir de uma interrupção ou evento externo, como o acionamento de um botão. De
acordo com informações existentes em (WIKIPÉDIA, 02/03/2012), quando em estado
normal, o µC tem um consumo na ordem de miliwatts e em modo sleep na ordem de
nanowatts. Segundo MIYADAIRA (2011), o gerenciamento da energia consumida pelo
µC PIC® é indispensável quando o circuito é alimentado por meio de bateria, pois
circuitos dessa natureza devem consumir o mínimo de energia a fim de maximizar o
tempo de carga da bateria.
Os microcontroladores, durante um tempo não tão distante, eram dispositivos de
alto custo econômico, o que restringia essa tecnologia a equipamentos mais complexos
e mais caros. Com o passar do tempo, devido a vasta gama de aplicações possíveis
com o uso desses componentes, passaram a ser produzidos em alta escala o que
levou a queda no preço dos chips e a popularização dos mesmos entre sistemas mais
simples.
Estima-se que brevemente em um lar comum de um país desenvolvido já é
possível encontrar mais de 20 microcontroladores nos mais diversos aparelhos. Outra
aplicação importante dos microcontroladores é na redução de consumo de recursos
naturais, um sistema baseado em microcontrolador pode monitorar o fornecimento de
determinado recurso de forma eficiente como é o caso de sistemas de injeção
eletrônica bicombustível nos automóveis e a redução do consumo de motores elétricos
(FELIPE, 2010).
Existem diversos fabricantes de microcontroladores no mercado que se diferem
na arquitetura interna, quantidade de memória interna, velocidade de processamento,
quantidade de entradas/saídas (I/O) e periféricos. Existem duas arquiteturas de
39
comunicação interna mais usadas entre os µC, a Harvard e a Von-Neumann. Na
Harvard a CPU utiliza barramentos separados para acesso das memórias de programa
e dados – aumentando o fluxo de dados. Na Von-Neumann as memórias de programa
e dado compartilham o mesmo barramento – limitando o fluxo de dados.
A Intel®, Motorola®, Atmel® e a Microchip®, são exemplos de fabricantes de
microcontroladores. Esta última tem se destacado com sua linha PIC, que abrange
desde componentes pequenos com 6 pinos e palavras de instrução de 12 bits até os de
100 pinos com palavras de instrução de 16 bits (SILVA, 2007).
Figura 2.9 – Diagrama simplificado de um µC baseado na arquitetura Harvard.
Como pode ser visto a Figura 2.9 demonstra a arquitetura de comunicação
Harvard, tecnologia adotada pela linha PIC de MCUs, onde a CPU faz uso de caminhos
diferentes para acessar as memórias. Essa linha é formada por diversas famílias com
capacidade de processamento de dados de 8, 16, 24 e 32 bits. Estes foram os
primeiros dispositivos com arquitetura RISC (Computador com conjunto de Reduzido e
Instruções), cuja simplicidade de projeto permite que mais facilidades sejam
adicionadas a um baixo custo. Os programas podem ser guardados nas memórias
flash, EEPROM (Electrically Erasable Programmable Read Only Memory) e OTP (One
Time Programmable). Trabalham com freqüência de até 48Mhz, usando ciclo de
instrução mínima de quatro períodos de clock o que permite velocidade máxima de
10MIPS (Milhões de Instruções Por Segundo) (ZORZIN, 2008).
40
Algumas das características de manipulação dos microcontroladores da linha PIC
que fazem com que eles se adaptem facilmente em diversas aplicações, estão listadas
a seguir:
• Comunicações I2C, SPI, RS-232, USB;
• TIMERs e contadores;
• Manipulação de memória EEPROM externa;
• Conversores A/D com até 12 bits de resolução;
• Módulos CCP e ECCP (Capture, Compare e PWM);
• Módulo Ethernet;
• Watchdog Timer;
• Real Timer Clock;
• Manipulação da pilha TCP/IP.
Todos esses recursos disponíveis tornam os MCUs dispositivos de grande
potencialidade, podendo ser realmente denominados computadores de tamanho
reduzido, os quais permitem o desenvolvimento de hardwares com toda essa
tecnologia embarcada. De acordo com a definição de ANDREANI (2007), um sistema
embarcado é um sistema de propósito específico em que o computador é
completamente encapsulado por um módulo de controle. Diferentemente de um
computador de propósito geral, tal como um computador pessoal, um sistema
embarcado desempenha tarefas pré-definidas, bastante específicas.
Sistemas embarcados podem possuir desde nenhuma interface do utilizador
(dedicados somente a uma tarefa) a uma interface completa, similar à dos sistemas
operacionais desktop (em sistemas como PDAs). Sistemas mais simples utilizam
botões, LEDs ou telas bastante limitadas, geralmente mostrando somente números ou
uma fila pequena de caracteres. O surgimento da World Wide Web forneceu aos
desenvolvedores de sistemas embarcados a possibilidade de fornecer uma interface
Web através de uma conexão por rede (WIKIPÉDIA).
Como dito por ZANCO (2005), o uso de microcontroladores no desenvolvimento
de projetos pode contribuir significamente para o desenvolvimento de nosso país. A
formação de mão-de-obra qualificada, em sintonia com as demandas de um mercado,
hoje globalizado, é um dos pilares para o desenvolvimento e o crescimento sustentável.
41
2.6 Internet Embarcada
Atualmente a Internet tem seu emprego em larga escala nos computadores
pessoais que dispõem de sistemas operacionais com todo o protocolo embutido em
seu kernel, cabendo aos usuários e programadores apenas utilizar esses recursos.
Esse sistema é e ainda será por muitos anos o carro-chefe das aplicações da grande
rede. Porém, com a evolução dos microcontroladores, uma nova geração de aplicações
está se formando, são as aplicações embedded (embarcadas) para a Internet
(MOKARZEL E CARNEIRO, 2004).
A internet se apresenta como um verdadeiro e grande leque de possibilidades,
permitindo a seus usuários a resolução de problemas e execução de muitas tarefas do
dia-a-dia sem precisar sair de casa, além de ser um ambiente de onde se pode obter e
divulgar muitas informações se mantendo como uma forte forma de comunicação a
qual as pessoas estão familiarizadas. A possibilidade de embarcar toda essa tecnologia
junto à arquitetura de dispositivos eletroeletrônicos traz grande versatilidade e
potencialidade na utilização dos mesmos, como o controle e monitoramento via
Internet.
Diversos equipamentos que utilizamos no dia-a-dia já possuem versões que se
conectam a Internet. Equipamentos como impressoras, câmeras entre outros dispõe
desta facilidade, permitindo configuração, disponibilidade de informações, e controle
sob suas operações.
Com tudo, pode-se observar que a tecnologia Internet embarcada se caracteriza
por possibilitar a conexão de sistemas embarcados à Internet. Os microcontroladores
estão entre os principais sistemas embarcados por executar ações como a aquisição e
manipulação de dados envolvidos em um processo e o acionamento de atuadores e
cargas a partir de sinais de saída.
Como exposto por SANTOS (2009), para que um sistema embarcado possa
conectar-se à Internet, o mesmo deve possuir os seguintes componentes:
• Pilha TCP/IP para sistemas embarcados;
• Controlador Ethernet;
• Interface de rede;
Levando em consideração o uso de um microcontrolador, o mesmo terá que ter
condições de manipular uma pilha TCP/IP (nesse caso a desenvolvida para uso em
microcontroladores e será gravada em sua memória flash) para que possa se conectar
42
a rede como se fosse um computador normal, estabelecendo conexão lógica com uma
máquina remota em um determinado segmento de rede. Deverá também ser conectado
a um controlador de rede (nesse caso um controlador Ethernet) para que os dados que
chegam e saem do microcontrolador sejam codificados na forma padrão para
manipulação junto à pilha. Um exemplo de controlador externo é o ENC28J60,
mostrado na Figura 2.10, fabricado pela Microchip®. Já a interface de rede é essencial
para estabelecer conexão física entre o dispositivo e um segmento de rede. Um
exemplo de interface de rede é mostrado pela Figura 2.11.
Uma vez contendo todos esses requisitos, tal sistema embarcado pode ser
considerado um Microservidor Web.
Figura 2.10 – Controlador Ethernet ENC28J60.
Figura 2.11 – Interface de rede 100/10BaseT
43
3 FERRAMENTAS UTILIZADAS NO DESENVOLVIMENTO DO PROJETO
3.1 Pilha TCP/IP da Microchip®
A pilha de protocolos TCP/IP para microcontroladores desenvolvida e fornecida
gratuitamente pela Microchip®, é similar a pilha TCP/IP utilizada em computadores.
Todos os seus protocolos foram desenvolvidos seguindo a documentação referente ao
padrão nas RFCs (Requests for Comments - solicitações de comentários) que são uma
série progressiva de relatórios, propostas de protocolos e padrões de protocolos que
descrevem os trabalhos internos do padrão TCP/IP e da Internet. Por tudo, a pilha
permite a conexão de microcontroladores à Internet como se fossem um
microcomputador comum.
Muitas implementações TCP/IP seguem o Modelo de Referência TCP/IP.
Softwares baseados nessa referência implementam seus protocolos em camadas, as
quais são “empilhadas” umas sobre as outras (daí o nome pilha TCP/IP). Cada camada
acessa os serviços de uma ou mais camadas diretamente abaixo. A Figura 3.1 ilustra
uma versão simples do modelo de referência TCP/IP e os serviços do modelo
implementado pela Microchip®.
A pilha desenvolvida pela Microchip® não implementa todos os módulos que
estão normalmente presentes na pilha TCP/IP tradicional. Embora não estejam
presentes, podem ser implementados como uma tarefa ou módulo separado, se
necessário (MICROCHIP’AN833C, 2008). Esse fato está diretamente relacionado pela
pilha ter sido desenvolvida para ser embarcada em microcontroladores, que são
dispositivos com espaço limitado de memória se comparados a microcomputadores
comuns.
44
Figura 3.1 – Comportamento do modelo de referência e protocolos implementados na pilha da microchip.
Na implementação deste projeto, serão utilizados quatro protocolos pertencentes
à pilha: Ethernet, IP, TCP e HTTP, cada um pertencente a uma camada do modelo
TCP/IP.
Os arquivos que formam a pilha são escritos na linguagem de programação ‘C’,
destinado aos compiladores C Microchip® C18, C30 e C32, HI-TECH ®, PICC-18. A
pilha TCP/IP da Microchip® foi projetada para aplicações envolvendo apenas a família
de microcontroladores PIC18, suportando dispositivos de 8, 16 e 32 bits.
Como informado acima, a pilha TCP/IP da Microchip® é dividida em múltiplas
camadas. O código de execução de cada camada reside em arquivos separados,
enquanto os serviços e API’s (Application Programming Interfaces – Interface de
Programação de Aplicativos) são definidos através de arquivos header/include. Ao
contrário do modelo de referência, a pilha TCP/IP da Microchip® pode acessar
diretamente uma ou mais camadas que não se encontram diretamente abaixo dela. A
comparação estrutural de acesso as camadas entre o Modelo de Referência TCP/IP e
a Pilha TCP/IP da Microchip® está ilustrada na Figura 3.2.
A decisão de quando uma camada deve contornar a adjacente é necessária, e foi
feita preliminarmente, devido à quantidade de “overhead” e levando-se em conta se era
necessário ou não fazer um processamento “pesado” antes de passar para a próxima
camada.
45
Figura 3.2 – Comparação estrutural do Modelo de Ref erência TCP/IP e a Pilha TCP/IP da Microchip. Fonte: MICROCHIP’AN833C, 2008.
Foram adicionados dois novos módulos na implementação da microchip em
relação ao modelo tradicional, o Stack Task, que gerencia as operações de todos os
módulos da pilha, permitindo acesso a níveis diferentes da pilha dependendo da
aplicação, e o ARPTask, que gerencia os serviços do protocolo de resolução de
endereços, camada ARP.
Esses módulos operam em conjunto sob uma técnica conhecida como
cooperative multitasking (multitarefa cooperativa). Nela, todas as tarefas devem ser
executadas compartilhando os recursos do sistema. Assim, as duas camadas operam
em conjunto da seguinte maneira, quando uma cumpre seus trabalhos ela gera um
sinal de controle para que a outra possa executar os dela. Essa característica permite a
pilha trabalhar de forma mais rápida e manter certa independência do programa
principal, tornando possível sua utilização em dispositivos com poucos recursos
(SANTANA, 2008).
Por isso, a pilha TCP/IP da Microchip® é chamada de pilha viva; algumas de
suas camadas podem executar operações de forma assíncrona. Tudo isso graças ao
cooperativismo multitarefa (onde as tarefas são executadas sequencialmente e de
modo independente). O programa principal envia cada tarefa para ser processada e, ao
final da sua execução, o controle retorna ao programa principal e só então a próxima
tarefa fica apta a ser executada (MICROCHIP’AN833C, 2008).
46
Normalmente, cooperativismo multitarefa é implementado pelo sistema
operacional ou pela aplicação principal em si. A pilha TCP/IP da Microchip® foi
projetada para ser independente de qualquer sistema operacional e, portanto,
implementa seu próprio sistema cooperativismo multitarefa. Como resultado, pode ser
usado em qualquer sistema, independentemente se ele usa um multitarefa do sistema
operacional ou não. No entanto, uma aplicação que utiliza a pilha TCP/IP da
Microchip® deve também utilizar o método cooperativo multitarefa. Isso é feito através
da divisão de um programa em múltiplas tarefas, ou organizando o programa principal
como uma máquina de estados finita (FSM) e dividindo um programa grande em
diversos programas pequenos (MICROCHIP’AN833C, 2008).
3.1.1 Servidor HTTP da Microchip®
O servidor HTTP da Microchip é implementado como uma tarefa cooperativa que
co-existe com a aplicação principal do usuário e a pilha TCP/IP. A implementação
desse servidor é feita no arquivo fonte “HTTP2.c”, com o aplicativo do usuário tendo
que implementar duas funções callback, funções que são chamadas automaticamente
pelo servidor HTTP e que devem executar alguma tarefa a ser definida pelo usuário
(MICROCHIP’AN833C, 2008).
Ainda de acordo com MICROCHIP’AN833C (2008), embora este servidor não
forneça todas as funcionalidades que um servidor HTTP típico, e sim, implementações
mínimas para sistemas embarcados, o usuário, conforme necessário pode adicionar
novas funcionalidades. As características principais incorporadas no Servidor HTTP
são:
• Suporte a múltiplas conexões HTTP;
• Contém seu próprio sistema de arquivos (MPFS – Sistema de Arquivos da
Microchip);
• Suporta programas localizados na memória interna do microcontrolador ou em
uma EEPROM externa;
• Suporta os métodos GET e POST;
• Suporta a geração de conteúdo dinâmico de páginas web;
• Suporta um tipo de CGI (Common Gateway Interface) para executar
funcionalidades pré-definidas a partir de um navegador remoto.
Para integrar o Servidor HTTP a um aplicativo do usuário, a AN833c (Applied
Note 833c) da Microchip informa que os seguintes passos devem ser seguidos:
47
1. No arquivo "StackTsk.h", deve-se habilitar o código do Servidor HTTP,
descomentando a macro STACK_USE_HTTP_SERVER.
2. No arquivo "StackTsk.h", junto a macro MAX_HTTP_CONNECTIONS, deve ser
definido o valor máximo de conexões para o Servidor HTTP.
3. Incluir no projeto os arquivos "http.c" e "mpfs.c".
4. Definir onde serão armazenadas as páginas web, se numa EEPROM externa ou
na memória Flesh do microcontrolador, através das macros MPFS_USE_PGRM
e MPFS_USE_EEPROM. Caso use memória externa, incluir no projeto o
arquivo "Xeeprom.c".
5. Modificar a função main() do aplicativo para incluir o servidor HTTP.
O servidor HTTP mantém uma lista dos tipos de arquivos suportáveis. Ele usa
essas informações para aconselhar os navegadores sobre como interpretar arquivos
específicos, com base nas extensões dos arquivos geralmente formadas por três letras.
Por padrão, o Servidor HTTP da Microchip suporta arquivos “. Txt”, “. Htm”, ”. Html”, “.
Xml”, “. Css”, “. Cgi”, “. Gif”, “. Png”, “. Cgi”, “. Jpg”, “. Cla” e “. wav”. Se um aplicativo
usa tipos de arquivos que não estão inclusos nesta lista, o usuário pode acessar o
arquivo “HTTP2.c” e modificar a tabela “httpFileExtensions”, juntamente com o
“httpContentTypes”. (MICROCHIP’AN833C, 2008).
3.1.2 Microchip File System 2 (MPFS2)
Como já citado, o controle do módulo será realizado a partir do fornecimento de
entradas por meio de páginas web, as quais estarão alocadas na memória interna do
microservidor ou em uma EEPROM externa. Para tanto, é necessário que essas
páginas sejam convertidas para um formato compatível para o armazenamento.
O servidor HTTP da Microchip® usa um sistema de arquivos simples (MPFS2 –
Microchip File System - Sistema de Arquivo da Microchip) para armazenar páginas
web. O MPFS2 segue um formato especial para armazenar vários arquivos em um
meio de armazenamento (MICROCHIP’AN833C, 2008). A Figura 3.3 apresenta essa
forma de armazenamento.
48
Figura 3.3 – Formato da imagem MPFS2 – Fonte: MICRO CHIP’AN833C, 2008.
O comprimento do Reserved Block – Bloco Reservado, é definido pela macro
MPFS_RESERVE_BLOCK. O bloco reservado pode ser usado pela aplicação principlal
para armazenamento de valores de configuração. O armazenamento MPFS começa
com uma ou mais entradas MPFS2 FAT (File Allocation Table – Tabela de Alocação de
Arquivos), seguido por um ou mais arquivos de dados. A entrada FAT descreve o nome
do arquivo, status e sua localização (MICROCHIP’AN833C, 2008). O formato da
entrada FAT é mostrado na Figura 3.4.
Figura 3.4 – Formato do FAT de entrada MPFS2 – Font e: MICROCHIP’AN833C, 2008.
O byte Flag, indica o estado da entrada atual, se está em uso, excluída, ou no
final da FAT.
Cada entrada do FAT contém 16 ou 24-bit. O comprimento do endereço é
determinado pelo tipo de memória utilizado, bem como o modelo de tamanho da
memória. Se for usada a memória de programa interna do dispositivo, o projeto é
compilado com o modelo de memória menor, é usado o endereço de 16-bits. Se
selecionados a memória interna de programação e o modelo de memória maior, é
usado o endereço de 24 bits. O esquema de endereço de 16 bits é usado para
memória EEPROM externa, independentemente do modelo de tamanho de memória.
Isso implica em uma imagem do MPFS2 de no máximo 64 Kb para a memória externa
(MICROCHIP’AN833C, 2008).
49
O MPFS2 utiliza um formato “8 + 3” para o nome de arquivos (8 bytes para o
nome real do arquivo e 3 bytes para o extensão, NNNNNNNN.EEE). O endereço de 16
bits dá início ao primeiro bloco de dados do arquivo. Os nomes dos arquivos são
armazenados em maiusculo para faciltar a comparação.
O campo de endereço em cada entrada FAT contém uma referência para um
bloco de dados que contém os dados do arquivo em questão. O formato do bloco de
dados pode ser visto na Figura 3.5. O bloco é terminado com um bit de flag especial de
8 bits chamado EOF (End Of File), seguido do valor FFFF (para endereçamento de 16
bits) ou FFFFFF (para endereçamento de 24 bits). Se a parte de dados do bloco
contém um caractere EOF, o mesmo é preenchido por um caractere de “escape”
(BACURAU, 2011).
Figura 3.5 – Formato do bloco de dados (MICROCHIP’A N833C, 2008).
3.2 Microcontrolador PIC18F87J60
Como já mencionado anteriormente, esse trabalho tem como objetivo o
desenvolvimento de um módulo microcontrolado com possibilidade de acesso a
Internet, caracterizando-se como um microservidor Web. O MCU a ser utilizado deve
ser capaz de manipular todos os códigos necessários para disponibilização de dados
na rede além de espaço de memória suficiente para armazenamento dos mesmos.
A Microchip® disponibilizou em sua linha PIC18, diversas funções
adicionais/inovadoras (SILVA, 2007). Como exemplo a possibilidade de conexão a
internet. Os modelos dessa linha possuem a capacidade de manipulação da pilha de
protocolos TCP/IP, mas, a grande maioria não tem capacidade de conexão direta com
a rede Ethernet necessitando do uso de um controlador externo. Outros modelos, como
o PIC18F87J60, trazem esse controlador embarcado em seu encapsulamento.
O PIC18F87J60 é construído com base na arquitetura Harvard, que possui
barramento de endereço e dados distintos, e com instruções do tipo RISC (Computador
com Conjunto Reduzido de Instruções). Possui uma CPU de 8 bits, dotado de 128
Kbytes de memória de programa e 3808 bytes de memória RAM. Pode ser alimentado
com tensões entre 2,5V e 3,6V. Esse modelo possui 80 pinos, como mostrado na
Figura 3.6, dos quais 55 podem ser configurados como I/O, módulo CCP com até
50
quatro saídas PWM, quinze conversores A/D de 10 bits de resolução, módulo SPI e
I²C, comunicação EUSART, em fim, todas as características que a família 18F oferece
alem, de um controlador Ethernet como um de seus blocos internos. A estrutura em
diagrama de blocos do PIC18F87J60 é mostrado na Figura 3.7. Essa plataforma é ideal
para utilização com a pilha TCP/IP para microcontroladores da Microchip, já que tanto a
pilha quanto a plataforma são produzidos pela mesma empresa, minimizando assim
problemas de incompatibilidade.
Figura 3.6 – Diagrama de pinos do PIC18F87J60.
Fonte: MICROCHIP, 2008.
51
Figura 3.7 – Diagrama de Blocos do PIC18F87J60.
Fonte: MICROCHIP, 2008
52
O módulo Ethernet incorporado nesse dispositivo traz uma solução completa de
conectividade, incluindo a implementação dos módulos MAC – Controle de Acesso ao
Meio, e a camada física (PHY), como ilustrado na Figura 3.8.
O módulo Ethernet atende todas as especificações da IEEE 802.3 para o padrão
de comunicação 10BaseT que se conecta a rede com o cabo de par trançado.
Incorpora uma série de esquemas de filtragem que limitam a entrada de pacotes.
Módulo DMA e IP Checksum.
Figura 3.8 – Diagrama de bloco do Módulo Ethernet - Fonte: MICROCHIP, 2008.
Como informado no datasheet o módulo Ethernet é composto por cinco blocos
fundamentais:
1- Módulo PHY que codifica e decodifica os dados analógicos enviados e recebidos
da rede pelo cabo de par trançado.
2- Módulo MAC que corresponde as implementações IEEE 802.3 e fornece a
Interface Independente de Gerenciamento de Mídia (MIIM) para controle da
PHY.
3- Buffer da RAM para armazenar pacotes recebidos e pacotes a serem
transmitidos com 8 Kbytes de transmissão/recepção.
53
4- Arbiter – árbitro para controlar o acesso ao buffer da memória RAM quanto aos
pedidos feitos pelo microcontrolador, DMA, e os blocos receptor (RX) e
transmissor (TX).
5- Interface de registro, que funciona como uma intérprete de sinais de comandos e
status entre o módulo e o microcontrolador SFR.
Outra característica bastante importante oferecida por esse dispositivo é que em
caso dos 128 Kbytes de memória de programa serem insuficientes, o mesmo
implementa um barramento de memória externa. Isso permite o tratamento de um
espaço de memória de até 2 Mbytes.
3.3 Especificação de Hardware
O PIC18F87J60, dispositivo escolhido pelo presente projeto devido suas
características já citadas no texto, possui pequenas dimensões físicas, 12x12x1 mm e
distância entre pinos de 0.5 mm como mostrado na Figura 3.9. Sendo, compacto ao
ponto de impossibilitar o seu manuseio e montagem de hardware em uma matriz de
contatos ou mesmo em uma placa de circuito impresso convencional.
Figura 3.9 – Dimensões físicas do PIC18F87J60.
Surgia aí a necessidade da pesquisa e obtenção de uma plataforma de baixo
custo, fácil acesso e que possuísse as características necessárias para o
desenvolvimento do sistema. Seguindo esses critérios foram localizadas algumas
opções de hardware que poderiam servir como base para o projeto, e foi selecionada
54
entre eles a placa PME10A da 2EI mostrada na figura Figura 3.10, por ter um custo
acessível e possuir a interface de rede que é essencial para a aplicação.
Figura 3.10 – Interface Ethernet PME10A de 10Mbps
A PME-10A é uma placa microcontrolada (PIC 18F87J60) com interfaces Ethernet
10 Mbps e serial RS-232. Ela pode ser adicionada a qualquer rede Ethernet 10/100
Mbps. Aplicações típicas incluem servidor Web HTTP, conversor de interface RS 232
para Ethernet, conversor de interface RS485 para Ethernet, controle remoto via Web,
conexão TCP/IP, correio eletrônico, Agent SNMP, Servidor WAP,etc. (2EI, 2007).
Os principais componentes da PME-10A são:
1 - Conector ICSP (In Circuit Serial Programming): Permite a placa PME-10A ser
conectada a uma interface de programação para gravação da memória Flash do
microcontrolador.
2 - Conector RJ45 (10 BaseT) que atende os requisitos IEEE802.3, possui leds
de indicação: Amarelo: Indica que a conexão Ethernet está ativa. Verde: indica
que a placa está transmitindo ou recebendo um pacote de dados.
3- Conectores de Expansão: Provê acesso de 53 pinos do microcontrolador
PIC18F87J60 para serem usados como E/S. Entradas e saídas digitais estão na
faixa de 0 a 3V3. A PME-10A pode ser alimentada diretamente por este conector
( + 3,3V no pino 28 de J1 e GND no pino 1 de J1).
4 - Microcontrolador: PIC18F87J60 com cristal de 25 MHz, 128K de memória
Flash, MAC integrado e PHY 10Base-T, 3808 bytes de memória RAM e 55
portas de I/O programáveis.
55
5 - Memória SPI EEPROM 25LC160 de 2Kbytes. Para configuração dos
parâmetros de rede.
6 - C.I MAX3232 para USART RS232.
7 - Conector Serial RS232: Provê os sinais Tx, Rx e GND para transmissão
serial assíncrona proveniente do integrado MAX3232.
Como a PME10A é constituída do PIC18F87J60 que suporta a pilha TCP/IP da
Microchip que por sua vez oferece suporte para compiladores Microchip C18, o código
do dispositivo é compilado pelo MPLAB C18, fornecido gratuitamente através do site
oficial da Microchip Technology (www.microchip.com).
Segundo MIYADAIRA (2009), o MPLAB C18 é um compilador C destinado aos
microcontroladores da família PIC18. Ele possui compatibilidade com o padrão ANSI
(American National Standards Institute) e pode ser facilmente integrado ao MPLAB IDE
permitindo depuração em nível de código com o “software” MPLAB. Suas principais
características são:
É compatível com o padrão ANSI.
Permite misturar códigos C e Assembly em um único projeto.
Permite configurar níveis de otimização do código.
Dispõe de uma vasta biblioteca (PWM, SPI, I2C, UART, USART etc.).
3.4 MPLAB IDE
O MPLAB IDE é um ambiente de desenvolvimento integrado, que permite fácil
integração com o compilador MPLAB C18 ou outro tipo de compilador, além de ser
uma ferramenta extremamente poderosa, pois ela gerencia o projeto, compila, simula,
debuga e em muitos casos grava no chip (MIYADAIRA, 2009). Desenvolvido e
fornecido gratuitamente pela Microchip® o MPLAB é executado como um aplicativo de
32 “bits” no sistema operacional Microsoft Windows, é de fácil utilização e possui um
conjunto de ferramentas para desenvolvimento e depuração de forma rápida e ágil de
aplicações embarcadas baseadas nos produtos da Microchip® (MICROCHIP, 2008). O
ambiente do MPLAB IDE v8.50 utilizado nesse trabalho pode ser visto na Figura 3.11.
56
Figura 3.11 – Ambiente de trabalho do MPLAB IDE v8. 50
3.5 PROTEUS
Para a simulação do projeto foi utilizado software Proteus que é um ambiente de
desenvolvimento e simulação de circuitos eletrônicos. É constituído por um conjunto de
programas como o ARES, que é uma ferramenta que permite o projeto de placas de
circuito impresso. O Proteus permite a simulação de sistemas eletrônicos constituídos
de microcontroladores a partir do código desenvolvido e compilado pelo MPLAB.
A princípio é possível desenvolver e testar um projeto utilizando o Proteus VSM
(Virtual System Modelling), antes mesmo de o protótipo físico estar construído. Isso é
possível porque o Proteus VSM simula através de animação em tempo real (ou bem
próximo disso) a integração e funcionamento de todos os componentes de um projeto e
oferece instrumentos virtuais (Osciloscópio, Multímetro, Analisador lógico, dentre
outros) para depuração dos circuitos (SANTOS, 2009).
A Figura 3.12 mostra o ambiente de desenvolvimento do Proteus VSM contendo
um dos exemplos de circuitos eletrônicos que o mesmo traz em sua biblioteca.
57
Figura 3.12 – Ambiente de desenvolvimento do Proteu s.
3.6 GRAVADOR PICkit2
O PICkit2, mostrado na figura 3.13, é um depurador/gravador que permite de
maneira fácil e rápida, depurar softwares em microcontroladores da linha 10F, 12F, 16F
e 18F e DsPic da Microchip. O gravador possui soquete padrão de gravação para PIC’s
de 8, 18, 28 e 40 pinos.
Figura 3.13 – Gravador PICkit2.
58
3.7 Ferramentas para o Desenvolvimento de Páginas W eb
3.7.1 Dreamweaver
Para o desenvolvimento das páginas web do Sistema foi utilizado o software
Dreamweaver CS3, Figura 3.14, produzido pela Adobe. Segundo BACURAL (2011), o
Adobe Dreamweaver, antigo Macromedia Dreamweaver é um software de
desenvolvimento voltado para a web criado pela Macromedia (adquirida pela Adobe
Systems). Este IDE incorpora um notável suporte para várias tecnologias web, tais
como XHTML, CSS, JavaScript, Ajax, PHP, ASP, ASP.NET, JSP, ColdFusion e outras
linguagens Server-side.
Figura 3.14 – Tela inicial do Dreamweaver CS3.
Outra funcionalidade do Dreamweaver é permitir selecionar a maioria dos
navegadores para se ter uma previsão (preview) da visualização do HTML ou da
página diretamente no(s) navegador(es) de destino. O software possui também ótimas
ferramentas de gerenciamento e transferência de projetos tais como a habilidade de
encontrar e substituir, no projeto inteiro, linhas de texto ou código através de
parâmetros especificados. (BACURAL, 2011).
59
3.6.2 Tecnologias para Aplicações Web
O HTML (Hipertext Markup Language – Linguagem de Marcação de Hipertexto) é
a linguagem básica para o desenvolvimento de páginas web. O texto a ser contido na
interface deve ser posto entre as tags (palavras ou caracteres entre sinais de maior e
menor, como <head>, <p>, <h1>) adequadas, para fornecer a estrutura correta e
desejada à página. É através das tags, que o browser sabe o formato adequado de
exibição da página web, ou seja, elas informam ao navegador qual parte do texto é o
titulo, qual parte é um parágrafo, qual merece destaque, onde determinada imagem
deve ser inserida entre outras informações.
Quando o servidor responde a uma solicitação, ele geralmente envia algum tipo
de conteúdo para o navegador, para que esse possa exibi-lo. Os servidores geralmente
enviam instruções para o navegador escritas em HTML, que os diz como apresentar o
conteúdo ao usuário. Ou seja, o HTML informa ao browser como exibir o conteúdo ao
usuário. (FREEMAN, 2008).
Vimos que o HTML é uma linguagem de marcação que especifica o formato de
texto exibido em um navegador web, mas o estilo da interface deixa a desejar. Para
oferecer melhor apresentação as informações já estruturadas, entra em cena uma
tecnologia da W3C denominada Cascading Style Sheets (CSS – folhas de estilo em
cascata), que permite especificar a apresentação dos elementos em uma página web.
Como exposto por DEITEL (2003), o desenvolvedor web pode inserir estilos nas
suas páginas de varias maneiras:
• Estilos in-line – onde se declara o formato de um elemento individual utilizando o
atributo style.
• Folhas de Estilo Incorporadas – permitem o autor da página incorporar um
documento inteiro de CSS na seção head de um documento HTML.
• Estilos Conflitantes – como o próprio nome indica, as folhas de estilos estão em
cascata, pois, os estilos podem ser definidos pelo usuário, pelo autor ou pelo
agente do usuário (por exemplo, um navegador web). Os estilos definidos pelos
autores assumem precedência sobre os definidos pelo usuário, e os do usuário
sobre os estilos definidos pelo agente do usuário.
• Folhas de Estilo Externas – as folhas de estilo dão uma maneira conveniente de
criar um documento em um tema uniforme. Com as folhas de estilo externas
(isto é, documentos separados que contêm somente regras de CSS), os autores
de página web podem fornecer uma aparência e um comportamento uniforme
60
para o site inteiro. Páginas diferentes em um site podem utilizar a mesma folha
de estilo. Em seguida, quando forem necessárias alterações para o estilo, o
autor das páginas web precisa modificar um único arquivo de CSS para fazer
alterações de estilo em todo o site.
A utilização desses padrões (HTML, XHTML e CSS), permite o desenvolvimento
de páginas simples, com poucos conteúdos gráficos e apenas conteúdos estáticos.
Aplicações desenvolvidas a partir desses conceitos trazem a vantagem de uma perfeita
integração com qualquer navegador web, além de não exigir profundos conhecimentos
do desenvolvedor.
No caso do trabalho em questão, que utilizará um navegador web como interface
de acesso ao microservidor, a página a ser desenvolvida deve conter características
que ofereçam meios para que o usuário tenha controle sob variáveis existentes em
hardware, variáveis estas, que mudam seus valores constantemente e que devem ser
atualizadas de forma dinâmica ao usuário, oferecendo-lhe acesso as informações de
campo em tempo real.
Para que uma interface web ofereça esses tipos de serviços, novas tecnologias
(alem do XHTML e do CSS) devem ser incorporadas à página. De acordo com FELIPE
(2010), várias são as propostas de inserção de parâmetros de controle e indicadores
gráficos em páginas dinâmicas, vejamos algumas dessas tecnologias:
• Labview – um software proprietário que oferece inúmeras potencialidades, entre
elas a possibilidade de acesso a dispositivos remotos via Internet. Possui uma
linguagem de programação combinada com ferramentas gráficas onde o
desenvolvedor pode fazer dos instrumentos virtuais já implementados que
podem se comunicar com instrumentos reais e podem ficar acessíveis por
qualquer navegador web a partir de um servidor HTTP embutido no próprio
LABVIEW. Sistemas desenvolvidos com base nessa tecnologia necessitam da
instalação da versão completa do software em seu servidor, o que envolve
elevados custos.
• Java applets – programa escrito em Java que pode ser inserido em páginas
HTML permitindo a interação do usuário com partes gráficas contidas na
interface, oferecendo capacidade de controle e monitoramento das diversas
variáveis envolvidas de um processo em tempo real. Entre as desvantagens
pode-se citar um alto tempo para sua inicialização e baixa velocidade de
operação, a necessidade de ter instalada a maquina virtual Java no computador
61
do cliente e uma das principais desvantagens é a variação de funcionalidade de
um applet entre diferentes navegadores.
62
4 IMPLEMENTAÇÃO DO PROJETO
4.1 Desenvolvimento do Software
Este capítulo traz informações referentes ao desenvolvimento das páginas web,
do funcionamento do servidor HTTP e das implementações junto a pilha TCP/IP para
microcontroladores da Microchip.
4.1.1 Desenvolvimento da Página Web
Uma atenção especial deve ser dada na escolha da forma de acesso ao
microservidor, visto que é por meio dela que o usuário terá acesso aos dados da
aplicação e controle sobre os mesmos.
Através da rápida abordagem realizada anteriormente sobre as tecnologias
existentes para o desenvolvimento aplicação web (que caracteriza o cliente na
aplicação remota), percebe-se inviabilidades na utilização tanto do software Labview
quanto de programas Java applets. Apesar das duas tecnologias compreenderem os
requisitos básicos para uma implementação de controle dinâmico junto ao
microservidor, ambas trazem desvantagens como o uso de uma plataforma proprietária
onde se faz necessário a instalação de seus softwares no microservidor envolvendo
custos no caso do Labview e, a variação de funcionalidade em diferentes navegadores
e a necessidade de programas específicos no computador do cliente, com o uso de
applets. Características que não condizem com a idéia da implementação de um
módulo de controle de baixo custo, com um sistema que funcione independente de
plataformas e sem a necessidade de instalação de softwares adicionais, podendo o
acesso ser feito de um computador, telefone móvel ou qualquer outro dispositivo com
conexão à Internet.
Outra abordagem poderia utilizar mais plenamente as funcionalidades dos
navegadores mais recentes, permitindo aplicações em JavaScript e XML (eXtensible
63
Markup Language), que dá ao cliente grande flexibilidade em armazenamento,
processamento e apresentação dos dados recebidos (FELIPE, 2010). O JavaScript é
uma linguagem aberta de scripts, considerada intermediária entre a linguagem Java e a
HTML, portanto pode ser usada por desenvolvedores de páginas HTML para tornar
suas páginas mais dinâmicas e interativas.
O desenvolvimento de páginas HTML dinâmicas é realizado a partir do ‘modelo
de objeto’, que permite que os programadores Web controlem a apresentação de suas
páginas e lhes fornece acesso a todos os elementos em sua página Web. A página
inteira – elementos, formulários, frames, tabelas, etc. – é representada em uma
hierarquia de objetos. Utilizando scripts, o autor é capaz de recuperar e modificar
dinamicamente qualquer propriedade ou atributo de uma página (DEITEL E NIETO,
2003).
Scripts podem responder as interações do usuário e alterar a página
consequentemente. Isso torna os aplicativos web mais reativos e amigáveis ao usuário,
alem de reduzir a carga no servidor executando tarefas localmente junto ao navegador.
O AJAX – Assyncronous Javascript and XML, é uma ferramenta que oferece aos
desenvolvedores web soluções na construção de páginas que necessitam de
atualizações constantes e de forma dinâmica. De acordo com SANTOS (2009), O
principal objetivo do AJAX é melhorar a interatividade do usuário com o servidor,
evitando interromper a interação do usuário com a página toda vez que a aplicação
necessitar de informações do servidor. Devido essas características, além do AJAX ser
atrativo visualmente, o mesmo economiza em recursos de banda já que a transmissão
de dados é bem menor, uma vez que as páginas não são recarregadas a cada nova
requisição e são páginas que ainda possibilitam a obtenção de informações em tempo
real.
A aplicação web desenvolvida para implementação do controle do sistema de
iluminação, foi programada com base em HTML e CSS somados a algumas funções de
Ajax e Javascript para fornecer maior interatividade ao usuário.
4.1.2 Servidor HTTP
A interface de controle e monitoramento do sistema via rede é implementada
através de um servidor HTTP embarcado no microcontrolador. Neste projeto foi
utilizado o servidor HTTP2 da Microchip.
64
A maioria das requisições ou solicitações que ocorrem na web entre clientes e
servidores é mantida através do protocolo HTTP, que possibilita conversas de
solicitação e resposta simples. O cliente envia uma solicitação HTTP e o servidor
retorna uma resposta HTTP. Quando o servidor envia uma página HTML ao cliente, o
faz usando o protocolo HTTP.
O HTTP roda no topo do TCP/IP. O TCP é responsável por garantir que um
arquivo enviado de um nó da rede para outro chegue íntegro ao seu destino, ainda que
o arquivo esteja dividido em blocos no momento do envio. O IP é o protocolo de
sustentação que transfere/roteia os blocos (pacotes) de um host para outro no seu
caminho até o destino. Ou seja, o HTTP é outro protocolo de rede que tem
características para web, mas ele depende do TCP/IP para obter solicitações e
respostas completas de um lugar para outro. A estrutura de uma conversa HTTP é uma
sequência simples de solicitação/resposta ; um navegador solicita e um servidor
responde (BASHAM, SIERRA e BATES, 2005).
O protocolo HTTP possui vários tipos de solicitação, conhecidos como métodos,
contudo, os mais usados são o GET e o POST. Esses tipos de solicitação recuperam e
enviam dados de um formulário do cliente para o servidor web.
A solicitação GET é o método mais simples do HTTP e seu principal trabalho é
pedir ao servidor que consiga um recurso. As informações do que se deseja receber do
servidor estão anexados ao Localizador Uniforme de Recursos (URL - Uniform
Resource Locators – que localiza o endereço de um recurso solicitado na web) exposto
na barra de endereços do navegador (na seguinte estrutura:
protocolo://máquina/caminho/recurso), e por isso, o total de caracteres que pode ser
enviado através do GET é limitado. A Figura 4.1 mostra um exemplo de solicitação via
GET ao servidor após do clique em um botão de uma página web.
Figura 4.1 – Solicitação via GET.
Nessa solicitação, as informações que seguem o ? (BTPAGINA=Controle )
indicam a entrada especificada pelo usuário. Ou seja, o sinal de interrogação separa o
caminho do parâmetro. Segundo NEVES (2008) para o servidor da Microchip estes
dados estão limitados até cerca de 80 bytes e os dados enviados via GET são
automaticamente decodificados e guardados no array curHTTP.data. A aplicação lida
65
com estes dados na função HTTPExecuteGet. As funções HTTPGetArg e
HTTPGetROMArg fornecem um método fácil de submeter valores para processar.
Como informado por DEITEL e NIETO (2003), os dados enviados por uma
solicitação POST não fazem parte da URL e não podem ser visto pelo usuário. Os
formulários que contêm muitos campos são normalmente enviados através de uma
solicitação POST. Os campos que diferenciam letras maiúsculas e minúsculas no
formulário, como senhas, normalmente são enviados com esse tipo de solicitação.
Não foram desenvolvidas simulações que necessitassem da implementação do
método de solicitação POST, mas o módulo pode ser empregado para controle de um
sistema em que seja necessário a utilização de tal método. Assim, na solicitação ao
microservidor via método POST, segundo NEVES (2008), os dados são submetidos
após os cabeçalhos de pedido terem sido enviados. Isto permite que os dados sejam
virtualmente ilimitados em questão de tamanho, desde que a aplicação os consiga
processar. Mas, a aplicação tem de ser capaz de lidar com a recepção de dados, o que
torna este método geralmente mais complexo. Os dados enviados via POST são
deixados no buffer TCP para que a aplicação os possa ir buscar assim que estiver
preparada para tal. A função HTTPExecutePost é chamada repetidamente até que a
função retorne HTTP_IO_DONE. A aplicação deve usar as funções TCPFind e TCPGet
para retirar os dados do buffer. Se for retornado HTTP_IO_NEED_DATA o servidor
executa novamente a função quando o buffer ficar novamente cheio.
4.1.3 Configuração da Pilha TCP/IP
No desenvolvimento do projeto foi utilizado a versão 5.25 da pilha TCP/IP da
Microchip. A partir da pilha exemplo iniciou-se o estudo de seu funcionamento e
estruturação, com a identificação dos principais arquivos dentre as centenas que
formam a pilha. Após esta fase, o próximo passo foi a inserção de dados e códigos
relacionados à aplicação pretendida, adaptando assim a pilha exemplo ao projeto.
Como já informado, a pilha é composta por diversas camadas e a implementação
dessas camadas é realizada em arquivos separados como mostra a Figura 4.2, os
quais foram acessados e compatibilizados com a implementação. Os conteúdos
dessas camadas são escritos na linguagem C, também utilizada nas modificações. O
compilador MPLAB® C18 é responsável pela compilação da pilha modificada.
66
Figura 4.2 – Menu de arquivos que compõem a pilha
Como infirmado por SANTANA (2008), os arquivos que compõem o projeto ficam
separados em duas pastas diferentes: Source Files e Header Files. A pasta Source
Files contém os arquivos de extensão .c, que são os programas propriamente ditos e a
pasta Header Files contém os arquivos de cabeçalho .h, que são arquivos de
configuração utilizados em conjunto com os arquivos C. A seguir estão comentados
resumidamente alguns dos principais arquivos que formam a pilha da microchip:
• HardwareProfile.h – Onde é realizada toda a configuração física de hardware,
como: a definição do nome do projeto; definição do compilador; definição do
microcontrolador a ser utilizado; configuração dos módulos do microcontrolador
– Watchdog Timer, osciladores, conversores, etc; frequência de clock utilizada,
configuração dos pinos físicos para conexão de: LEDs, memória EEPROM
externa, botões, reles, controlador ethernet externo, caso necessário, display
LCD, enfim o mapeamento do hardware em relação aos pinos físicos;
• MainDemo.c – Onde fica alocada a função principal, e onde são configuradas as
portas já habilitadas no arquivo Hardwareprofile.h, com relação as condições de
I/O, configurado também os canais analógicos e a inicialização do LCD, se for
utilizada na aplicação;
67
• CustomHTTPApp.c - Neste arquivo estão contidas as funções de autenticação
das páginas, desenvolvidas as aplicações web, definido os métodos de envio
(GET ou POST) e onde são implementadas as funções de retorno das variáveis
dinâmicas das páginas web exibidas pelo servidor HTTP2;
• TCPIPConfig.h - Contem todas as definições da camada de aplicação da pilha
TCP/IP. São definidos: os protocolos usados (ICMP, HTTP, SMTP etc); onde
será feito o armazenamento de dados (memória EEPROM ou memória Flash); o
sistema de arquivos usado (MPFS ou MPFS2); IP, Máscara, Gateway, DNS e
host name; endereço MAC; opções da camada de transporte (TCP e UDP);
configurações específicas das aplicações;
• HTTP2.C - Este é o arquivo onde está programado o servidor web da pilha, nele
estão configurados os tipos de arquivo suportados e é onde são feitas as
alterações de programação que permitem o uso de páginas para aparelhos
celulares. O servidor web responde requisições da Internet através do programa
principal pelo uso de duas funções HTTPGetVar e HTTPExecCmd, onde:
HTTPGetVar - função utilizada para enviar valores de variáveis dinâmicas
do programa do PIC para o site;
HTTPExecCmd - função utilizada para capturar para dentro do programa
do PIC, variáveis enviadas através de formulários no site (SANTANA,
2008).
• HTTPPrint.h - Definição das variáveis dinâmicas das páginas web e chamada
das funções de manipulação das mesmas;
• StackTsk.c e StackTsk.h - Coordena a chamada das tarefas da pilha.
4.1.4 Testes Desenvolvidos no Simulador
A partir do momento que foram definidas as variáveis dinâmicas a serem
observadas e controladas no sistema, foi desenvolvida a página web de acordo com as
mesmas. Logo depois foram feitas todas as mudanças e inserção de códigos na pilha
necessários para o funcionamento da aplicação pretendida. O passo seguinte foi o
desenvolvimento do circuito eletrônico no Proteus- ISIS versão 7.7 referente ao circuito
da aplicação real para serem iniciados as simulações de software e hardware do
sistema. O circuito foi construído conforme apresentado na Figura 4.3.
68
Figura 4.3 – Circuito eletrônico em simulação.
Para a simulação do circuito é necessário a compilação da página web através do
programa MPFS e da pilha através do C18 gerando o arquivo hexadecimal a ser
carregado no microcontrolador no ambiente de simulação.
A Figura 4.4 mostra o Sistema de Arquivos da Microchip (MPFS2 - programa
gerado junto a instalação da TCPIP Stack v5.25), responsável por compilar as páginas
web. Na maneira que está configurado (opções de processamento – saída: C18/C30
Image) é gerado um arquivo .c o qual após a compilação do projeto será gravado na
memória interna do microcontroador. Este método é mais simples de usar, mas é
limitado ao tamanho da memória do microcontrolador.
69
Figura 4.4 – Compilador das páginas web.
Ao ser clicado em ‘Generate’, será compilada a página carregada no MPFS e
surgindo uma nova janela, Figura 4.5, a qual fornece informações como a quantidade
de arquivos e de variáveis que página contém e o espaço que a mesma ocupará na
memória do PIC.
Figura 4.5 – Informações referentes a página web co mpilada.
70
Outra possibilidade é a de gravar a página em uma memória EEPROM externa.
Nesse caso o programador deverá selecionar a opção de saída ‘BIN Image’ junto ao
MPFS, que gerará um arquivo binário (.bin) – que é a página web convertida em um
formato que o MCU conhece. Este arquivo deverá ser carregado na EEPROM através
do mpfsupload, como mostra a Figura 4.6.
Figura 4.6 – Arquivo mpfsupload carregado no navegador .
Ao definir a memória a ser utilizada para a gravação das aplicações web, é
necessário informar essa escolha a pilha TCP/IP através do arquivo TCPIPConfig.h por
exemplo, se for usada uma EEPROM externa a opção #define MPFS_USE_EEPROM
deve ser descomentada.
O projeto utilizado nas simulações difere em alguns aspectos do projeto real da
aplicação pelo motivo da inexistência do PIC18F87J60, empregado nesse trabalho, na
biblioteca do Proteus. O dispositivo utilizado na simulação foi o PIC18F4620 interligado
ao controlador Ethernet externo ENC28J60, como foi mostrado na Figura 4.3.
4.2 Desenvolvimento de Hardware
Devido a tensão de operação do PIC18F87J60 ser de 3,3V, enquanto muitos dos
dispositivos usados em circuitos microcontrolados operam com 5 ou 12V, foi
necessário montar um circuito de alimentação que inicia a partir de uma simples fonte
portátil que fornece 12V DC para o módulo, esta tensão é então rebaixada
primeiramente para 5V, através do regulador de tensão L7805, e em seguida para
3,3V, com o regulador LM1117, daí segue-se a alimentação para PME10A (3,3V). 5V e
12V são utilizados no circuito condicionador de sinal de rede e alimentação dos relés
respectivamente. A Figura 4.7 mostra o módulo desenvolvido.
71
Figura 4.7 – Módulo montado para o controle de ilum inação via web.
Para o acionamento das cargas envolvidas nas implementações que o módulo
poderá vir ser conectado, foram montados junto a três saídas do mesmo três reles, e
seus respectivos circuitos de funcionamento, um conector RJ12 ligado a interface ICSP
da PME10A para que o microcontrolador possa ser programado e conectores de
entrada e saída de sinais provenientes da aplicação.
Para o exemplo de aplicação do módulo com Ethernet embarcada proposto por
esse trabalho – a vigilância e controle de um circuito de iluminação, foi necessário a
utilização de um circuito de condicionamento de sinal para que a tensão de rede (220
AC) fosse detectada por uma das entradas do microcontrolador. Os principais
componentes deste circuito, ilustrado na Figura 4.8, são o Fotoacoplador PC817 e a
ponte de diodos W04.
72
Figura 4.8 – Circuito condicionador de sinal
Este circuito permite que o microcontrolador possa identificar a presença de
tensão (220V AC) em um determinado ponto. O optoacoplador é responsável por isolar
diferentes partes do circuito.
Os reles são responsáveis por liberar ou não a tensão de retorno para o
sistema de iluminação. Os estados (on/off) dos reles são comandados a partir de
sinais lógicos de tensão provenientes do microcontrolador.
Quando a iluminação não é acionada pela página e sim localmente, o
interruptor acionado envia a tensão de rede para o módulo, nesse momento entra em
cena o optoacoplador que isola essa tensão recebida, liberando apenas um sinal lógico
para o microcontrolador, que enxerga como sinal de entrada e faz o seu trabalho de
gerenciamento gerando um sinal de saída para o circuito do rele que por sua vez libera
a tensão de retorno da rede para as luzes. Nesse mesmo tempo a pagina é atualizada
e indica que a iluminação esta acionada graças as requisições assíncronas via Ajax ao
microservidor.
Componentes utilizados para a montagem do hardware:
Placa PME10A;
3 reles;
4 diodos 1N4007;
3 transistores BC337 e 1 BC558;
5 LED’s;
1 fotoacoplador PC817;
73
1 ponte de diodos W04;
2 resistores de 22K, 1 de 220Ω, 5 de 10K;
1 conector RJ12;
1 conector para fonte de 12V;
1 regulador de tensão L7805 e 1 regulador LM1117;
2 capacitores eletrolíticos de 10 µF e 1 de 100 µF;
3 capacitores cerâmicos de 100 nF;
Conectores de I/O.
A tabela 2 contem os custos relacionados a implementação do hardware.
Tabela 2 – Custo do projeto
Componente Quantidade Valor Unitário Custo
Placa PME10A 1 R$ 113,00 R$ 113,00
Relés 3 R$ 3,00 R$ 9,00
Fotoacoplador PC817 1 R$ 2,50 R$ 2,50
Transistor BC558 1 R$ 3,00 R$ 3,00
Transistor BC337 3 R$ 0,50 R$ 1,50
Placa para montagem 1 R$ 12,00 R$ 12,00
Componentes em geral - - R$ 35,00
Total R$ 176,00
74
5 FUNCIONAMENTO DO PROJETO PROPOSTO
5.1 Gravação da Página Web e da Pilha TCP/IP no Módulo
Uma vez que o módulo se encontre montado, a aplicação web desenvolvida, a
pilha TCP/IP modificada para a aplicação e ambas compiladas, chega o momento da
gravação do software em hardware. A gravação é realiza da através do conector RJ12
do módulo que está ligado ao conector ICSP (In Circuit Serial Programming), que
permite a placa PME10A ser conectada a interface de programação PICkit2 para
gravação do firmware na memória Flash do microcontrolador. A Figura 5.1 mostra a
interface de gravação do PICkit2.
Figura 5.1 – Interface de gravação PICkit2.
75
5.2 Funcionamento da Aplicação Web Junto ao Microse rvidor
Os sinais de entrada aplicados no microservidor são provenientes da chegada de
requisições pelo navegador geradas pela ação do usuário junto à página web, que
geralmente são dotadas de botões e/ou figuras clicáveis.
A responsável pela identificação do estado físico do circuito de iluminação na
página web são figuras de lâmpadas, formatadas como links de dados, que servirão
como meio de inserção de entradas (requisições HTTP via método GET do navegador)
ao microservidor através de um clique do mouse sob a imagem. Estas imagens
deverão ser constantemente modificadas, acompanhando o estado real da iluminação
em hardware.
Tais modificações ocorrerão de forma praticamente instantânea, graças às
requisições Ajax ao microservidor que ocorrerão a cada 500ms, modificando
dinamicamente a interface web com as atualizações de campo informadas pelo
servidor.
De acordo com as informações recebidas, a imagem que integra o corpo da
página será substituída por outra que corresponda o estado atual do hardware. Ou
seja, levando em consideração que inicialmente o circuito de iluminação ligado ao
módulo se encontre desativado (luzes apagadas), a imagem referente a esse circuito
na página deve ser correspondente a esse estado (imagem de uma lâmpada apagada).
A partir do momento que o usuário acionar o sistema junto a página, clicando na
imagem, requisições vão ser enviadas ao microservidor que irá processá-las e em
seguida acionará o circuito correspondente fazendo com que as luzes se ascendam
fisicamente. Logo, o servidor deverá retornar informações relacionadas ao estado atual
de suas saídas, permitindo a atualização da página (troca da imagem – lâmpada
acesa).
O texto a seguir descreve de forma mais detalhada o funcionamento da interface
web junto ao microsservor.
Ao ser dado um clique na imagem, referente a um dos circuitos controlados,
denominada “iluminação 1”, será provocada uma solicitação Ajax ao servidor através
da chamada da função newAJAXCommand() que carrega os campos
('luzes.cgi?luz=1') e os envia ao servidor via método GET (dados da solicitação são
enviados na própria url).
Com a utilização da função, ‘newAJAXCommand()’, vão ocorrer constantes
solicitações de envio de dados informados na url ao microservidor.
76
Ao chegar informações diretamente pela url ao servidor, a função
HTTPExecuteGET(), localizada no arquivo CustomHTTPApp.c, é chamada
automaticamente, onde dados são decodificados e armazenados no vetor
curHTTP.data em pares de nome e seu valor correspondente. As funções
HTTPGetArg() e HTTPGetROMArg() podem encontrar facilmente o nome da variável
procurada e assim executar a ação necessária de acordo com o seu valor. Ou seja, a
função HTTPExecuteGET() identifica através dos parâmetros recebidos via GET, qual
arquivo (página web) e qual o nome ou dado pertencente a tal página foi enviado na
requisição, em seguida executa as linhas de códigos referente ao dado recebido,
gerando sinais de saída para acionar/desativar o circuito de iluminação
correspondente.
Se analisarmos os passos seguidos e os resultados adquiridos até o presente
momento, observaremos que o usuário acessou a página de controle do sistema
embarcada no microservidor, enxergou os dados informados pela interface web,
forneceu entradas através da mesma no intuito de modificar o estado atual em
hardware, e o servidor levou essas requisições até o microservidor o qual as processou
e gerenciou sinais de saída que promoveram uma ação em hardware segundo as
entradas fornecidas pela página de controle via web. Ou seja, apesar das mudanças no
meio físico, até então, o usuário da interface não tem informações sobre o ocorrido em
hardware após sua ação sob a página.
A resposta do microservidor ao navegador, ou seja, a impressão dos dados atuais
do hardware na página, se dá a partir da execução da função HTTPPrint(), a mesma se
encontra dentro do arquivo CustomHTTPApp.c da pilha. Mas, para o desenvolvimento
de códigos que irão servir de base para o retorno de dados ao cliente, se faz
necessário que algumas etapas tenham sido seguidas. Vejamos quais são:
No momento da estruturação da página web, que deverá fornecer condições de
monitoramento e controle de um dado sistema a partir de um microservidor, o
desenvolvedor deve ter em mente toda a relação de variáveis estáticas e dinâmicas a
serem alocadas na interface para que a mesma ofereça funcionalidade e dinamismo
junto ao processo. Uma vez feito essas definições, os arquivos referentes a estrutura
da página devem ser convertidos para um formato compatível para o armazenamento.
Essa compilação é feita pelo Sistema de Arquivos da Microchip (MPFS2).
Na compilação da página web o programa MPFS2, além de gerar a imagem da
interface web, que poderá ser embarcada na memória do microcontrolador ou em uma
77
memória EEPROM externa (depende da maneira que a imagem for criada - .c ou .bin,
como já informado no texto), ele também irá gerar automaticamente na pilha o arquivo
HTTPPrint.h, que possui as informações de cabeçalho que vão informar a pilha TCP/IP,
quais são as funções existentes responsáveis por manipular as variáveis estáticas e/ou
dinâmicas da página.
Tudo acontece da seguinte maneira: no momento que os arquivos são
compilados e a imagem da página web é gerada, o arquivo HTTPPrint.h será
atualizado automaticamente com as variáveis pertencentes a página. A partir dessas,
ele faz chamadas de funções relacionadas às variáveis. Essas funções são
desenvolvidas dentro do arquivo CustomHTTPApp.c, onde, a partir de seus códigos,
fornecem informações a página sempre que solicitado.
Se tratando de variáveis estáticas contidas na interface, o processo de tratamento
é relativamente simples, bastando apenas a página ser carregada junto a um
navegador web para que as informações contidas na função HTTPPrint()
correspondente a variável forneça seus valores ao cliente.
No momento em que passa-se necessário trabalhar com variáveis dinâmicas, ou
seja, a existência de campos na interface web que mudem seus valores de acordo com
mudanças ocorridas em hardware, outros arquivos, contendo funções específicas,
devem ser somados ao projeto da página além das linguagens HTML e CSS, utilizadas
na sua estruturação e aparência. Como exemplo, funções de JavaScript, Ajax e XML.
As variáveis dinâmicas existentes nas aplicações web, como no caso das
lâmpadas, no exemplo que esse trabalho traz, devem ser contidas em um arquivo ‘
.xml’ (neste caso, status.xml), escritas na forma ~luz(1)~, como mostra a Figura 5.2.
Através do caractere ~ o microservidor reconhece que se trata de uma variável
dinâmica e através da função HTTPPrint() referente à variável, substitui por seu valor
atual antes de enviar o arquivo status.xml ao cliente.
Figura 5.2 – Exemplo de variáveis no arquivo status .xml.
Como informado por FELIPE (2010), toda a informação necessária para
atualização do estado na página se obtém do arquivo status.xml. Uma vez que a
78
página é carregada por completo se inicia um código Javascript que realiza o envio de
solicitações AJAX do recurso status.xml através da função newAJAXCommand como
mostrado na Figura 5.3.
Figura 5.3 – Requisição ao arquivo xml.
Essa função chama o arquivo status.xml, onde estão informados os valores atuais
das variáveis a serem atualizadas. Chama também a função updateStatus que é
responsável por comparar o valor existente no arquivo .xml com o existente na página
naquele momento, promovendo a troca, ou não, da imagem. O ultimo parâmetro ‘true’,
indica que a solicitação deve ser repetida infinitamente e a cada 500ms, assim como
está configurada a função do Javascript, setTimeout.
Com a comunicação assíncronas do Ajax, é eliminada a necessidade de
atualização da página inteira a cada requisição do usuário, sendo realizado apenas a
atualização dos dados necessários, oferecendo mais eficiência na transmissão dos
dados e maior interatividade com o usuário.
5.2.1 Funcionamento do Módulo Junto ao Sistema de I luminação
Após a execução de todos os passos, implementações de hardware, software e
gravação dos programas no microservidor do módulo, é então chegado o momento de
conectá-lo ao sistema de iluminação e a uma rede de trabalho local ou a internet, como
demonstra a Figura 5.4.
Figura 5.4 – Esquemático do módulo conectado a rede e ao sistema de iluminação.
79
A Figura 5.4 esquematiza o sistema embarcado em ação a partir do controle
de uma lâmpada (L1). Neste contesto, a chave (CH), que se encontra em seu estado
fechado e representa um interruptor, está ligada a fase da rede elétrica e a uma das
três entradas do módulo, já a lâmpada, ao neutro da rede e a uma das três saídas do
módulo. As linhas vermelhas indicam que as mesmas estão alimentadas pela tensão
de fase, a azul que está alimentada por uma tensão de retorno proveniente do módulo,
e as linhas pretas representam o neutro. No momento o protótipo só possui três
entradas e três saídas, lembrando que a PME10A contida no mesmo, utiliza o
PIC18F87J60, que disponibiliza 53 portas de I/O (entrada/saída). Por tanto, mais
conectores podem ser incluídos no módulo se assim for necessário.
Mesmo com a implantação do módulo, a iluminação do ambiente pode também
ser acionada normalmente a partir do interruptor, como exemplificado na Figura 5.4,
desde que o operador da página de controle contida no microservidor permita.
A Figura 5.5, traz a página de acesso ao controle via web que esta embarcada
no microcontrolador. Uma vez que protótipo esteja conectado a internet, a página
contida no mesmo pode ser acessada - através do número de seu endereço IP
(Protocolo da Internet), ou ainda através do seu host name (nome dado a página) que é
definido dentro do arquivo TCPIPConfig.h da pilha TCP/IP - de qualquer lugar do
mundo por qualquer dispositivo que ofereça acesso a internet e utiliza um navegador
web.
Figura 5.5 – Página de acesso ao controle de ilumin ação via Web
Devido a tantas facilidades e tantos meios, qualquer pessoa pode ter acesso a
página. Por isso mesmo se torna necessário a configuração de um sistema de acesso
80
seguro o qual permite o alcance a aplicação de controle somente a pessoas
autorizadas após inserção de login e senha. A configuração de autenticação da página
esta contida no arquivo CustomHTTPApp.c, onde ficam as funções HTTPNeedsAuth()
– que informa qual página necessita de autenticação, e a HTTPCheckAuth – que checa
a informações inseridas pelo usuário na caixa de login em senha e compara com os
valores configurados na pilha. Caso os dados informados não sejam os corretos a
função retorna ao navegador uma mensagem de não autorizado. Após realização das
configurações a pilha TCP/IP fará uma requisição de login e senha toda vez que
alguém quiser acessar a página de controle como demonstrado na Figura 5.6.
Figura 5.6 – Requisição de login e senha para acess o a página de controle
Após tal procedimento o usuário estará na página de controle referente a
sala definida. A partir dessa interface é possível saber o estado atual da iluminação
(luzes acesas ou apagadas), e defini-lo em tempo real. A Figura 5.7, traz as
informações de estado da sala (a iluminação da sala é dividida em dois circuitos
distintos, relacionados na página como (LED) e (RELÉ) respectivamente), nesse
instante o operador percebe que a iluminação referente ao circuito2 está ativada, pois
vê a figura de uma lâmpada (RELÉ) acesa. Percebe também que o botão se encontra
no estado liberado o que indica que o sistema de iluminação pode ser acionado
localmente por qualquer pessoa através do interruptor. Nesse caso a iluminação pode
ter sido acionada tanto pela página como localmente.
81
Figura 5.7 – Status da sala (luzes acesas e sistema liberado)
Através de um clique sobre o botão o operador da aplicação web deixa o sistema
bloqueado o que impede o acionamento da iluminação localmente, o que passa a ser
possível somente através da página. Para apagar ou acender as luzes basta um clique
sobre a figura da lâmpada, o que corresponde a uma requisição do navegador junto ao
microservidor o qual processa a informação e gera um sinal de saída apagando ou
acendendo as luzes e envia um sinal de resposta ao navegador que modifica
dinamicamente o estado do botão e da luz, como mostrado na Figura 5.8
.
Figura 5.8 – Status da sala (circuitos desligados e sistema bloqueado)
82
6 CONCLUSÃO
Esse trabalho tratou da implementação de um módulo de baixo custo,
microcontrolado com ethernet embarcada com possibilidade de acionamento através
da internet. Uma vez conectado a rede mundial, tal sistema possibilita o monitoramento
e acionamento de cargas, conectadas ao mesmo, de qualquer lugar do mundo, desde
que se tenha acesso a internet e um navegador web. Trouxe ainda como exemplo de
aplicação, o controle de um sistema de iluminação o qual proporciona ao operador da
página, total liberdade sobre o condicionamento das luzes do ambiente, facilitada pelo
desenvolvimento de um aplicativo web dinâmico que interage com o usuário trazendo
informações em tempo real sobre o sistema controlado.
Conclui-se também que o desenvolvimento desse sistema baseado na tecnologia
dos microcontroladores, possibilitou a produção de um dispositivo flexível, pois é fácil
realizar adaptações no módulo para que o mesmo venha atender as diversas
necessidades que se apresentem, maximizando seu poder de conexão a diversos
equipamentos e sistemas a baixos custos. Tudo isso se soma ao momento atual onde
esta claro que a quantidade de equipamentos com tecnologias de comunicações
embarcadas tende a crescer, aumentando o número de dispositivos ligados a internet,
portanto um estudo profundo sobre suas estruturas de conectividade é imprescindível
para o desenvolvimento da atual e ainda pouco explorada, tecnologia de sistemas
microcontrolados com Ethernet embarcada vinculada a automação nos processos de
acionamento e monitoramento que regem ambientes industriais e residenciais.
Como possibilidade de trabalhos futuros, é proposto um estudo mais profundo
sobre a estrutura da pilha TCP/IP, tendo como resultado condições de utilizar todos os
seus recursos permitindo aplicações de maior complexidade fazendo uso de sistemas
microcontroladores com acesso a rede em aplicações de automação.
83
7 REFERÊNCIAS BIBLIOGRÁFICAS
ANDREANI, A. C. Sistemas Embarcados: Estudo Através de um Servidor HTTP.
Trabalho de Conclusão de Curso, Universidade Estadual de Londrina, 2007.
BACURAU, R. M. Desenvolvimento de um Sistema Web Embarcado para Co ntrole
e Supervisão de Estações Urbanas de Distribuição de Água. Trabalho de
Conclusão de Curso, UNIVASF, 2011.
BASHAM, B. Servlets & JSP TM / Bryan Basham, Kathy Sierra e Bert Bates. Rio de
Janeiro: Alta Books, 2005.
CASTELLS, M. A sociedade em Rede / Manuel Castells. 6. Ed. – São Paulo: Paz e
Terra, 1999.
DEITEL, H. M. Internet & World Wide web / H. M. Deitel, P. J. Deitel e T. R. Nieto. 2.
Ed. – Porte Alegre: Bookman, 2003.
FOROUZAN, B. A. Comunicação de Dados em Redes de Computadores / Behrouz
A. Forouzan. 3. Ed. – Porto Alegre: Bookman, 2006.
FELIPE, A. G. M. Laboratório de experimentação remota com o microcon trolador
PIC / Ágio Gonçalves de Moraes Felipe. Dissertação de Mestrado. UECE, 2010.
FREEMAN, E. HTML com CSS e XHTML / Elisabeth Freeman e Eric Freeman. 2. Ed.
– Rio de Janeiro: Alta Books, 2008.
KUROSE, J. F. e ROSS, K. W. Redes de Computadores e a Internet : Uma
Abordagem Top-down. 3. Ed. – São Paulo : Pearson Addison Wesley, 2006.
LUGLI, A. B. Sistemas Fildbus para automação industrial: DeviceN et, CANopen, SDS e Ethernet / Alexandre Baratella Lugli, Max Moura Dias Santos. 1. Ed. – São Paulo: Érica, 2009.
LUGLI, A. B. Redes Industriais para automação industrial: ASI-I, PROFIBUS e PROFNET / Alexandre Baratella Lugli, Max Moura Dias Santos. 1. Ed. – São Paulo: Érica, 2010.
MICROCONTROLADOR. In: WIKIPÉDIA: a enciclopédia livre.Disponível em:
<http://pt.wikipedia.org/wiki/Micorcontrolador> acesso em: 02 mar. 2012.
MICROCHIP. Microchip TCP/IP Stack Application Note
84
http://ww1.microchip.com/downloads/en/AppNotes/00833c.pdf - <acessado em 21 de Fevereiro de 2012>.
(MICROCHIP,2008C) – Microchip PIC18F87J60 Data Sheet – WWW.alldatasheet.com/datasheet-pdf/pdf/MICROCHIP/PIC18F87J60.html - <acessado em 15 de Fevereiro de 2012>.
MIYADAIRA, A. N. Microcontroladores PIC18: aprenda e programe em lin guagem
C / Alberto Noboru Miyadaira. 1. Ed. – São Paulo: Érica, 2009.
MOKARZEL, M. P. Internet Embedded: TCP/IP para Microcontroladores . / Marcos
Perez Mokarzel, Karina Perez Mokarzel Carneiro.1. Ed. São Paulo: Érica, 2004.
NEVES, S. R. Cybercar “Sistemas de Supervisão e Controle de um V eículo
Elétrico”. Dissertação de Mestrado, FCTUC, 2008.
PILHA TCP/IP. In: WIKIPÉDIA: a enciclopédia livre. Disponível em:
<http://pt.wikipedia.org/wiki/TCP/IP > acesso em: 29 fev. 2012.
SANTANA, L. V. O Uso da Internet e da Comunicação Sem Fio Via Zigb ee em
Sistemas Embutidos. Trabalho de Conclusão de Curso, UFOP, 2008
SANTOS, J. C. M. Projeto de um Sistema Microcontrolado Utilizando In ternet
Embarcada para Monitoramento Remoto em Tempo Real d e Temperatura e
Disponibilização dos Dados na WEB Através de Conexã o de Rede . Trabalho de
Conclusão de Curso, UFRN, 2009.
SISTEMAS Embarcados. In: WIKIPÉDIA: a enciclopédia livre. Disponível em:
<http://pt.wikipedia.org/wiki/Sistema_embarcado> acesso em: 02 mar. 2012.
SOUZA, D. J. Desbravando o PIC / David José de Souza. 11. Ed. – São Paulo: Érica, 2007.
STEMMER, M. R. Redes Locais Industriais: a integração da produção através das redes de comunicação / Marcelo Ricardo Stemmer – Florianópolis: Ed. Da UFSC, 2010.
TANENBAUM, A. S. Redes de Computadores / Andrew S. Tanenbaum. 13a Reimpressão. – Rio de Janeiro: Elsevier, 2003.
TORRES, G. Redes de Computadores Curso Completo / Gabriel Torres. Rio de Janeiro: Axcel Books do Brasil Editora, 2001.
SILVA, J. B. Monitoramento, Aquisição e Controle de Sinais Elétr icos via Web,
Utilizando Microcontroladores . Dissertação de Mestrado, UFSC, 2002.
85
SILVA, J. B. A Utilização da Experimentação Remota Como Suporte para
Ambientes Colaborativos de Aprendizagem. Tese de Doutorado, UFSC, 2006.
SILVA, L. E. G. Arquitetura Expansível Para Desenvolvimentos de Pág inas AJAX.
Dissertação de Mestrado, UFMG, 2009.
ZANCO, W. S. Microcontroladores PIC 16F628A: uma abordagem práti ca e
objetiva / Wagner da Silva Zanco. 1. Ed. – São Paulo: Érica, 2005.
ZORZIN, R. S. Monitoração Ambiental Remota Baseada em Microcontro ladores .
Trabalho de Conclusão de Curso, ULBRA, 2008.