Protocolo IPV6 será adotado no Brasil a partir de julho

Se você trabalha com dispositivos TCP/IP, preste bem atenção nesta notícia, veiculada pela TV NBR. A mudança deverá ser gradual.

Dicas de implementação de IPv6 em microcontroladores.

O artigo abaixo se encontra no site do EETimes, e é muito importante em nossos dias, onde a mudança de padrões para a internet começa a ser testada. A implementação do IPv6 em sistemas embarcados poderá ser muito importante nesta mudança.

IPv6 em um microcontrolador
Robert Muchsel
Uma das forças motrizes da mudança do PIv4 para o IPv6 tem sido dispositivos embarcados de baixo custo, que estão se conectando a um passo acelerado. Mas espremer toda a suíte de protocolos IPv6 em um pequeno microcontrolador 8-bits é um esporte radical de primeira ordem. Aqui estão algumas dicas de alguém que fez isto com sucesso.

O espaço de endereços para a Internet está ficando pequeno. Enquanto alguns endereços IPv4 ainda estão por ser alocados, e hacks como o IP masqueradinge aluguel de endereços temporários atrasaram o momento, nós todavia acabaremos ficando sem endereços nos próximos anos. Para garantir que futuros dispositivos conectados à Internet tenham endereços únicos, a próxima geração do Internet Protocol, IPv6, estende o espaço de endereçamento bem acima da imaginação humana: 2¹²⁸, que é cerca de 6.67 x 10²³ endereços por metro quadrado de nosso planeta; em outras palavras, bastante.
Tendo endereços suficientes elimina a necessidade de Network Address Translation (NAT) (também conhecido como mascaramento de IP), aluguel temporário de endereço, e outras correções necessárias para conservar os bem racionados endereços IPv4. A indústria espera um grande número de dispositivos de rede clássicos como computadores desktop e servidores, mas um tremendo número de pequenos dispositivos - incluindo dispositivos sem fio e móveis "sempre conectados", como celulares e PDAs, e sensores instalados em qualquer coisa desde carros até medidores de água de refrigeradores - irá mudar a natureza do tráfego de Internet como conhecemos hoje.
Claro, o IPv6 faz mais do que simplesmente estender o espaçamento de endereço. Este upgrade do IPv4 (não há IPv5 - o ID de protocolo 5 foi usado para o Internet Stream Protocol, RFC 1819) torna a configuração de nó fácil e automática - outro ponto favorável para aplicações embarcadas. Isto também faz a rede como um todo ser mais robusta e extensível, e adiciona características de segurança e suporte para qualidade de serviço não disponíveis anteriormente. Mais importante, o IPv6 também ajuda na velocidade e simplificação de roteamento, que se tornaram um gargalo à medida que o uso da Internet aumentou.
O reestruturado e melhor IPv6 já é distribuído amplamente e configurado para gradualmente substituir o IPv4. Muitos, se não todos os roteadores já estão atualizados. Tendo progredido além do estágio de protótipo, agora forma uma parte padrão da maioria dos sistemas operacionais desktop, incluindo Windows XP, Mac OS X, Solaris e Linux. Enquanto isto stacks IPv4/IPv6 duais permitem ambientes mistos e uma migração gradual para o IPv6. (Onde o IPv6 não é suportado ainda, nós podem ainda se comunicar através de "túneis" sobre intermediários IPv4).
Este artigo introduz algumas das mudanças no IPv6 e sugere dicas práticas para adicionar rede IPv6 a dispositivos baseados em pequenos microcontroladores como o 8051. Assume-se que o leitor possua conhecimento básico de redes e uma razoável experiência com IPv4.

Visão geral do IPv6
Um aspecto importante da capacidade de auto-configuração do IPv6 é a forma que os endereços são usados. Um endereço de 128 bits IPv6 é tipicamente dividido em um prefixo de 64 bits (chamado de net bits, que define a sub-rede) e 64 bits de host. O prefixo, que também mostra o escopo de um endereço, pode ser atribuído pelo provedor de rede e enviado por broadcast por roteadores, ou ele pode ser local ao site. Geralmente, os primeiros 48 dos bits de rede são atribuídos pelo ISP; os outros 16 estão dentro dos cuidados do proprietário do site.
Na Ethernet, os 64 bits de host podem ser derivados do endereço físico único de 48 bits, também conhecidos como endereço (veja barra lateral sobre endereços EUI-64) media access control (MAC). Em outras palavras, ao contrário do IPv4 onde os endereços IP e os endereços MAC são distintos, cada nó IPv6 combina todos endereços em um só e possui um endereço IP válido assim que ele se conecta. Novamente, ao contrário do IPv4 (que requer ajuda de um servidor BOOTP/DHCP), todos os nós IPv6 podem ser auto-configuráveis, mesmo na falta de um servidor. Para comunicar globalmente, o nó deve solicitar ou escutar os broadcasts do roteador contendo o prefixo e então combinar o prefixo com o EUI-64.

Endereços EUI-64
O identificador único extendido de 64 bits, ou EUI-64, foi definido em antecipação à possível sobrecarga do espaço de endereçamento único de 48 bits (EUI-48). Tanto o EUI-48 quanto o EUI-64 definem os primeiros 24 bits como o Company_ID, que é administrado pela IEEE Registration Authority Committee (http://standards.ieee.org/regauth). A organização proprietária do respectivo Company_ID atribui e administra os bits restantes.
A RFC 2373 descreve como inserir um par de valores de 8 bits (FF e FE) depois do terceiro octeto no meio do MAC de 48 bits para derivar o EUI-64.
Por exemplo, se 00-60-35 é o Company_ID e o endereço MAC de 48 bits de um nó é 00-60-35-23-45-67, o EUI-64 deste nó será 00-60-35-FF-FE-23-45-67.
Para gerar um endereço IPv6 que especifique aquele nó suficientemente para a rede local, o prefixo FE80:0000:0000:0000 é inserido e, seguindo as regras da RFC 2373, o bit 1 no primeiro octeto do EUI-64 é setado: FE80:0000:0000:0000:0260:35FF:FE23:4567.

Endereços IPv6 são escritos em notação hexadecimal e em grupos de 16 bits. Por exemplo:

3FFE:AAAA:BBBB:CCCC:0260:35FF:FE8D:6EE9

é um endereço de escopo global. A mesma máquina teria o endereço de "link local" FE80::0260:35FF:FE8D:6EE9, onde o FE80::/64 é o prefixo para endereços de link local, (o número depois da barra mostra o comprimento do prefixo, neste caso 64, e :: representa zeros). O host de loopback (127.0.0.1 na linguagem IPv4) é simplesmente ::1. Endereços locais de site possuem um prefixo de FEC0::/10, mas já que não há equivalente direto de endereços locais de site no IPv4, estes endereços são raramente usados hoje.
Já que longos endereços hexadecimais de 128 bits são difíceis para humanos entenderem, eles são normalmente escondidos por trás de nomes domain name system (DNS) como www.embedded.com. Um servidor DNS capaz de usar IPv6 (por exemplo, BIND9) é necessário para servir endereços de IPv6. A tradução de endereços IPv6 não incorpora fundamentalmente novos conceitos, então uma entrada de endereço IPv6 no DNS seria criada, por exemplo, como:

IN AAAA 3FFE:AAAA:BBBB:CCCC:0260:35FF:FE8D:6EE9

ao invés do similarmente formatado registro IN A usado no IPv4. O uso do DNS é fortemente encorajado, já que se espera mudanças mais frequentes nos prefixos de IPv6 do que de endereços IPv4. Renumeração de rede é muito mais fácil com o IPv6 e pode até mesmo ser automatizado.
O IPv6 inclui tanto endereços de unicast quanto multicast. Além disto, ele define um novo destino de anycast. Um pacote endereçado para um IP de anycast é entregue ao mais próximo ou melhor de vários hosts disponíveis. O anycast ajuda a balancear cargas através do roteamento e é um avanço considerável sobre o round-robin DNS (usado no IPv4), que não leva em conta detalhes de roteamento.

Camadas superiores
O IPv6 mantém as camadas superiores de protocolo, UDP e TCP, sem mudanças. Contudo, o cabeçalho de pacote IP é modificado para acomodar os endereços maiores. O cabeçalho de pacote IP é também limpo e simplificado para ser alinhado em 64 bits, para o benefício de roteadores, para que sempre tenham um comprimento fixo.
O checksum do cabeçalho IP não é mais usado porque o UDP e TCP possuem checksums que incluem partes daquele cabeçalho. Roteadores podem rotear pacotes mais rapidamente se eles não tiverem que primeiro recalcular o checksum do cabeçalho em cada pacote. Para compensar a potencial corrupção de cabeçalho de pacote IP, o checksum de camada mais alta é feito mandatório no UDP. Era opcional em sistemas IPv4, apesar de muitos hosts usarem ele.
Uma modificação interessante é a substituição do Address Resolution Protocol (ARP) do IPv4 com o novo Neighbor Discovery Protocol (NDP), que é parte do Internet Control Message Protocol versão 6 (ICMPv6). Ao invés de mandar broadcasts de requisição de resolução de endereços para todos os hosts, o IPv6 mapeia grupos de multicasts e endereços de IPv6 de uma forma que elimina broadcasts e assegura que um dado nó receba (quase) somente o trafego que é de interesse dele (veja a barra lateral sobre grupos de multicast).

Grupos Multicast
Um endereço multicast que é computado como função do endereço do nó é chamado um endereço de multicast de nó solicidado. O algoritmo completo é definido na RFC 2373. Em resumo, o endereço multicast de nó solicitado é formado tomando-se os 24 bits de ordem menor do endereço e anexando aqueles bits ao prefixo FF02:0:0:0:0:1:FF00::/104.
Por exemplo, o endereço de nó FE80::260:35FF:FE23:4567 se torna FF02::1:FF23:4567.

Os detalhes do ICMPv6, multicasting e NDP estão além do escopo deste artigo. Mais informação sobre estes e outros tópicos está disponível em www.ipv6.org.

IPv6 embarcado
O novo mundo de dispositivos embarcados traz o TCP/IP para as menores ferramentas e as conecta à rede. Enquanto a visão da torradeira em rede de forma justa morreu com o desaparecimento de certas companhias de startup, a conectividade é uma característica desejável para outros dispositivos do dia a dia, tais como medidores de energia, gravadores de vídeo pessoais e máquinas de respostas.
Há várias abordagens para se adicionar redes TCP/IP a dispositivos embarcados. Uma prática comum é usar um sistema operacional, tais quais VxWorks, Windows CE, ou Linux, com uma suíte de protocolo TCP/IP incluída. Se estas soluções não se adequam à sua plataforma, você pode adicionar um de um grande número de implementações de terceiros do stack TCP/IP para quase qualquer um sistema operacional real-time.

Micro IPv6
Se hardware muito potente (processador e memória) está fora de questão em seu sistema, parecerá difícil implementar o IPv6. Muitos sistemas embarcados, por exemplo, possuem menos de 64KB para código e 128KB para dados, incluindo toda a memória disponível para o OS, stack TCP/IP com suporte ao IPv6 e a própria aplicação.
Felizmente, a implementação completa de todas as funções do IPv6 não é tecnicamente necessária em várias áreas. Estas áreas são esclarecidas no documento InternetNode "Requerimentos mínimos de ferramentas IPv6 para redes de baixo custo" (este documento, juntamente com outros, está disponível em http://www.taca.jp/docs.html). Em particular, muitas funções de roteamento são opcionais. Por exemplo, a segurança é frequentemente também disponível no nível de aplicação (especialmente se a aplicação tem que dar suporte ao IPv4). O IPv6 pode ser canalizado sobre redes IPv4 existentes ("6over4", no jargão), mas esta é outra área onde o código pode ser removido de end nodes.
Na Dallas Semiconductor, nós modificamos uma suíte de protocolo IPv4 mínima para compatibilidade com IPv6. Nós tínhamos como alvo um microcontrolador baseado em 8051, o DS80C400, com 64KB de ROM^[1].
Quando nós começamos a implementar o IPv6 juntamente com o IPv4, nós fomos tentados a simplesmente duplicar o código, por exemplo ao criar um módulo TCP6 próximo de um TCP4. Isto foi eliminado, no entanto, por nosso apertado "orçamento" de memória. Ao invés de criar um segundo set de rotinas, nós modificamos implementações existentes de protocolo de alto nível (TCP, UDP, e outros) para trabalhar tanto com IPv4 quanto com IPv6.
A realidade é que aplicações existentes hoje suportam IPv4 e a vasta maioria das novas aplicações irão ainda operar sob o IPv4, não IPv6. Para justificar o suporte ao IPv6 do lado da aplicação, o stack de rede tem que tornar o menos doloroso possível adicionar suporte IPv6 a uma aplicação. Por exemplo, uma implementação que tem uma função socket() para IPv4 e uma função separada socket6() para IPv6 não será provavelmente bem recebida pelos desenvolvedores. Mantendo as implementações de protocolos de alto nível e a API os mesmos para ambas versões tornará mais fácil para o programador de aplicação adaptar-se às mudanças.
Nós rapidamente descobrimos que um número de otimizações eram necessárias para espremer o IPv6 em nossa pequena ROM. Além de estabelecer limites óbvios como o tamanho máximo de pacote suportado, uma idéia que nos salvou de muita dor de cabeça foi sempre usar endereços de 128 bits de tamanho, mesmo com o IPv4. Já que o prefixo ::0/96 (12 bytes de zeros no início) não é atualmente usado pelo IPv6 com exceção do localhost ::1, nós declaramos todos os endereços começando com ::0/96 como sendo endereços IPv4 e colocamos os endereços IPv4 de fato nos restantes 32 bits. Isto eliminou um grande número de construções if-then-else, tornou desnecessários flags de endereço de protocolo, e simplificou enormemente a passagem de parâmetros. É verdade que não há mais localhost IPv6 mais, mas o localhost IPv4 (127.0.0.1) ainda funciona e, quando se fala consigo mesmo, ninguém realmente importa muito com qual o protocolo usado.

Tabela 1: O tamanho do código TCP/IP na ROM do DS80C400
Módulo	Tamanho de código	IPv4	IPv6	Compartilhado
ARP	1111	X
DHCP	2366	X
ICMP	1949	X
IGMP	1346	X
IP	2487	X
ICMP6/Ping6	3346		X
IP 6	6999		X
NDP6	7962		X
Driver Ethernet	2677			X
TCP	10494			X
TFTP	584			X
UDP	1225			X
Tamanho total	42546	9259	18307	14980

Tabela 1 mostra o tamanho de código para cada módulo na suíte revisada de protocolo TCP/IP. O código foi escrito em assembler para 8051.

Preparar, apontar, fogo!
IPv6 está se tornando mais importante. Suporte a esta tecnologia será crucial para o sucesso de muitos dispositivos embarcados vindouros. Além de melhorar o protocolo IP, IPv6 fornece auto-configuração, um número virtualmente ilimitado de endereços IP e alguns alinhamentos do protocolo IP e do processo de roteamento.
A implementação do IPv6 em um dispositivo embarcado pode ser cheio de manhas, e você terá que fazer compromissos. Os benefícios, contudo, valem a pena, e não é de forma alguma impossível - mesmo em um microcontrolador de 8 bits com 64KB de ROM.

Robert Muchsel é um engenheiro de software senior na Dallas Semiconductor. Ele possui um diploma em ciências da computação do Instituto Federal Suíço de Tecnologia em Zurique e tem desenvolvido software por 12 anos. Seu endereço de e-mail é robert.muchsel@dalsemi.com.

Notas finais
1. A porção IPv6 do software do DS80C400 foi desenvolvido em colaboração com InternetNode, um empreendimento conjunto de Yokogawa e Wide Research Institute.

Páginas dinâmicas e AJAX no PIC.

Como eu havia dito em outro post, vou continuar nossa matéria sobre servidores Web no PIC. Nesta última parte, estarei descrevendo como você poderá inserir variáveis dinâmicas em suas páginas, bem como usar AJAX para atualizá-las.
Uma coisa que critico muito na plataforma da Microchip é a falta de documentação sobre este assunto. No entanto, se formos observar, há uma falta de documentação em toda nossa área. Espero assim preencher uma lacuna existente em nossa área.
Bem, se vocês acompanharam nossa última postagem, estarão com um servidor Web pronto para usar. Devemos agora criar nossas variáveis dinâmicas.

Criando variáveis dinâmicas na página Web

A Microchip definiu uma forma para a criação de variáveis dinâmicas em páginas Web. O padrão adotado é colocar o nome da variável entre dois '~'. Assim, poderíamos criar uma página web com o seguinte código HTML:

<html>
<head>
<title>Contagem de itens</title>
</head>
<body>
<p>Até o momento foram produzidos ~varItens~ itens.</p>
</body>
</html>

Criamos então aqui, uma página que irá mostrar o valor de uma variável chamada varItens. Esta página faz parte de um projeto que irá contar a quantidade de certos itens produzidos em uma indústria. Você deverá salvar esta página em seu diretório de páginas HTML, e então através do programa MPFS.exe (localizado na pasta [Raiz]\Microchip Solutions\Microchip\TCPIP Stack\Utilities), você irá gerar o código para ser incluído em seu programa. Se tudo ocorrer bem, o programa gerará o arquivo HTTPPrint.h com um novo protótipo de função:

void HTTPPrint_varItens(void);

Esta é a função que você deverá implementar para que sua variável dinâmica seja corretamente impressa no browser.
 
Implementando a função de impressão de variáveis dinâmicas
 
Vamos então criar uma função que imprime o valor de uma variável inteira chamada de quantItens. O nome da variável que escolhemos no código HTML não nos obriga a adotá-lo em parte alguma do código,pois escolhemos ali o nome da nossa função de impressão.
Assim, nossa função se chamará HTTPPrint_varItens. Eis o código-fonte desta função:

void HTTPPrint_varItens(void) 
{
   char tmpBuff[6];
   sprintf(tmpBuff, "%d", quantItens);
   TCPPutString(sktHTTP, (BYTE*)tmpBuff);
}

O que fiz foi basicamente converter o valor inteiro contido na variável quantItens para uma string, e usando a função TCPPutString, enviamos os dados para o browser que estiver visualizando a página. Tudo que for enviado através da função TCPPutString será exibido na posição que definimos no código HTML pela variável ~varItens~. Assim, não imprimimos apenas valores inteiros, mas também strings com mensagens para nossos usuários, códigos HTML para formatação de mensagens, etc...
 
Usando AJAX
 
Como implementar o AJAX em um servidor com PIC? A tarefa não é tão complexa assim. Imaginemos então que nosso projeto tenha que monitorar em tempo real a quantidade de itens na linha de produção, e que o browser deverá atualizar esta leitura sempre. Como implementar isto?
O primeiro passo será criar um arquivo que a página Web que criamos deverá buscar sempre com novas leituras. Este arquivo deverá ser um arquivo XML, e seu código pode ser visto abaixo:

<leitura> 
<contagem>~varItens~</contagem>
</leitura>

Observem que o elemento raiz é chamado de leitura, e os itens estão dentro de uma tag que chamamos de contagem.
Aqui neste arquivo, que vamos chamar de leitura.xml, nós colocamos novamente a impressão da variável varItens, que irá chamar a função que definimos acima. Novamente usamos o arquivo MPSF.exe para converter estes arquivos para um formato que possa ser utilizado pelo compilador.
Precisamos agora de algum mecanismo para buscar este arquivo no servidor e atualizar nossa página. Quem trabalha com Web poderia muito bem criar algumas funções em Javascript para usar o AJAX. No entanto, a Microchip já disponibiliza um arquivo Javascript que implementa o AJAX, e já faz o trabalho de atualizar periodicamente uma área de sua página Web.
O grande detalhe aqui é que a Microchip não divulgou muito isto. Não é um arquivo que está separado em uma pasta, somente esperando para ser usado. Este arquivo na verdade faz parte de um de seus exemplos, e pode ser encontrado na pasta [Raiz]\Microchip Solutions\TCPIP Demo App\WebPages2. O nome deste arquivo é mchp.js. Você deverá copiar este arquivo para sua pasta de páginas Web, e fazer algumas modificações no arquivo HTML que apresentamos acima:

<html>
<head>
<title>Contagem de itens</title>
<script type="text/javascript" src="mchp.js"></script>
<script type="text/javascript">
/* <![CDATA[ */
function displayItens(r)
{
  document.getElementById('leitura').innerHTML = getXMLValue(r, 'contagem');
}
function init()
{
  newAJAXCommand('leitura.xml', displayItens, true);
}
/* ]]> */
</script>
</head>
<body onload="init();">
<p>Até o momento foram produzidos <span id="leitura">~varItens~</span> itens.</p>
</body>
</html>

Em primeiro lugar, usamos um elemento SPAN para conter o valor a ser atualizado. Desta forma, limitamos a área onde será atualizada. É importante definir um ID para este SPAN, pois através deste localizaremos este elemento.
Definimos também a propriedade onload do elemento BODY. Quando a página carregar, ela irá invocar a função nesta propriedade. Vemos também que o código agora inclui dois scripts javascript: um é nosso arquivo mhcp.js, o outro é o nosso código.
Este nosso código simplesmente invoca a função newAJAXCommand, que faz todo o trabalho. O primeiro parâmetro desta função é o nome do arquivo que ela irá buscar no servidor. No nosso caso, é o arquivo leitura.xml que criamos anteriormente. O segundo parâmetro é o nome da função que será chamada, quando o arquivo for recebido. Criamos a função displayItens para este propósito, e por isto fornecemos este nome para a função. O terceiro parâmetro indica se você deseja repetir este chamado periodicamente, ou se este será um chamado apenas. No nosso caso, como desejamos uma leitura em tempo real, deixamos o valor como true. Esta função permite ainda um quarto parâmetro, que não vamos usar. Este parâmetro te permite enviar outras variáveis via POST para seu servidor.
Enviando o comando, o seu servidor responderá, enviando o arquivo leitura.xml. Quando recebermos o arquivo, ele será processado pela função que você passou como parâmetro para a função newAJAXCommand. Ela deve ter um parâmetro, que é o objeto XML que recebemos. Assim, para obtermos um item deste objeto, usamos a função getXMLValue. Ela recebe dois parâmetros. O primeiro, é o objeto XML que desejamos processar. Passe o objeto que recebemos como resposta. O segundo parâmetro é a tag no arquivo XML, que desejamos obter do arquivo. Como vocês podem se lembrar, colocamos a leitura dentro de uma tag contagem. Assim, passamos isto como parâmetro. Atribuímos então este valor à propriedade innerHTML do nosso SPAN, e pronto! Nosso valor estará sendo atualizado o tempo inteiro.
 
Conclusão
 
Temos então nosso servidor Web no PIC, utilizando variáveis dinâmicas e AJAX. A partir deste exemplo muitas outras adaptações poderão ser feitas, para atender aos requerimentos de cada projeto.

Criando um servidor Web no PIC

Olá, pessoal. Muito tempo sem postar por aqui...
Bem, estive ocupado em meu serviço tentando descobrir como criar um servidor Web usando os microcontroladores da família PIC. O grande lance destes microcontroladores é que a Microchip já fornece gratuitamente as bibliotecas necessárias para fazer isto. A questão é que não é muito simples de se configurar, sem muita documentação sobre isto. Por isto resolvi fazer uma descrição sobre este tema aqui.

Preparando terreno

Para que todos possam entender como se configura este projeto a partir do zero, resolvi detalhar todo o processo a partir do download dos arquivos necessários, no site da Microchip.
Assim, o primeiro passo é fazer o download, para quem ainda não fez, do MPLAB, que é a IDE para desenvolvimento de projetos no PIC. Para mim, este é um passo fundamental, já que através do MPLAB, você configura e depura projetos com o PIC muito facilmente. O link para o download do MPLAB (última versão), está aqui:
http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en019469&part=SW007002

Mas este não será o único download no site da Microchip. É importante também fazer o download de algum compilador C deste fabricante. Como este compilador dependerá do microcontrolador que você irá usar, então haverá escolhas diferentes aqui. Como exemplo, irei usar o compilador C18. A página abaixo possui um link para os vários compiladores disponíveis:
http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en534868&page=wwwCompilers

Pode-se fazer o download da versão lite destes compiladores, que são versões que não usam todas as otimizações do compilador versão full. Para mim está de bom tamanho para fazer este tipo de desenvolvimento, já que estes compiladores costumam ser muito caros para hobistas.
Tendo feito o download do compilador, resta agora fazer o download das bibliotecas da Microchip para TCP/IP e outros. Isto pode ser feito no link abaixo:
http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2680&dDocName=en547784

Muito bem, terminamos com as etapas de downloads... Agora vamos para a parte de instalação, que não é muito complicada. Só para garantir que tudo dará certo, vamos instalar o MPLAB primeiro, o C18 depois e por fim as bibliotecas da Microchip. Não tenho nenhuma observação a fazer aqui, embora eu recomende que deixe que as instalações sejam feitas na raiz da unidade C, para diminuir o caminho a ser incluido nos projetos. Agora estamos prontos para iniciar nosso projeto.

Iniciando o projeto

Quando procurei saber como iniciar um projeto de servidor HTTP no PIC, encontrei várias sugestões me indicando o projeto TCPIP Demo App, que é instalado junto com as bibliotecas da Microchip. Pessoalmente não gostei muito disto, pois o projeto por se tratar de uma demonstração, foi feito para incluir vários tipos de demonstração. Acho que não é necessário copiar todos os arquivos desta pasta. Os arquivos que são necessários para o projeto são os arquivos TCPIPConfig.h e HardwareProfile.h. Através destes arquivos, você poderá configurar seu projeto. Você precisará mudar manualmente o arquivo HardwareProfile.h.
Eu por exemplo tenho aqui uma placa Explorer16BR, da Mosaico. Todo mundo poderia achar que pelo fato de haver uma definição EXPLORER_16 neste arquivo, bastaria habilitá-la para que tudo funcione perfeitamente, certo? Bem, a verdade é que a Mosaico andou alterando alguns pinos nesta placa, e entre eles está justamente o pino de habilitação do Driver Ethernet. Portanto, se alguém estiver usando esta placa, procure pela definição

#else // SPI1 for all other processors
 #define ENC_CS_TRIS (TRISDbits.TRISD14)
 #define ENC_CS_IO (LATDbits.LATD14)

E altere para:

#else // SPI1 for all other processors
 #define ENC_CS_TRIS (TRISCbits.TRISC4)
 #define ENC_CS_IO (LATCbits.LATC4)

Há também a opção de se criar o arquivo do zero. Neste caso, a pessoa deve criar algumas definições obrigatórias neste arquivo, como está abaixo:

#ifndef __HARDWARE_PROFILE_H
#define __HARDWARE_PROFILE_H

#include "GenericTypeDefs.h"
#include "Compiler.h"

// Define os fusíveis de configuração (apenas uma vez)
#if defined(THIS_IS_STACK_APPLICATION)
 #if defined(__18CXX)
  #if defined(__EXTENDED18__)
   #pragma config XINST=ON
  #elif !defined(HI_TECH_C)
   #pragma config XINST=OFF
  #endif
  
  #pragma config WDT=OFF, FOSC2=ON, FOSC=HSPLL, ETHLED=ON

 #endif
#endif // Previne a definição de mais de uma vez dos mesmos fusíveis

// Valor da frequência de clock.
// Este valor é usado para calcular o valor de Tick Counter
#define GetSystemClock()      (41666667ul)      // Hz
#define GetInstructionClock() (GetSystemClock()/4)
#define GetPeripheralClock()  GetInstructionClock()

No caso, as definições que devem ser feitas são as definições de clock do sistema. Você precisa verificar qual as configurações de frequência você está usando, para criar estas definições.
Feito isto, podemos agora configurar a parte de TCP/IP. Para isto, a Microchip desenvolveu um executável que faz toda a configuração para nós. Este executável se encontra na pasta:
[Diretório instalado]\Microchip Solutions\Microchip\TCPIP Stack\Utilities

E o executável se chama TCPIPConfig.exe. Execute ele e forneça o caminho para seu projeto. Não se esqueça de marcar a opção Show Advanced Settings, para podermos configurar nosso projeto nos mínimos detalhes. Na próxima tela teremos várias opções de projeto:

Selecionaremos apenas Web Server. Selecionando Next, teremos várias opções de códigos de exemplo. Não iremos selecionar nenhuma destas opções aqui. Clicando-se novamente em Next, teremos uma seleção de módulos:

Aqui selecionamos ICMP Client, ICMP Server e o NetBIOS Name Service. Os dois ICMP são necessários para que a aplicação possa fazer PING em computadores e para que ela possa também responder a este comando, muito útil para verificar a conectividade de dispositivos. O NetBIOS Name Service será importante para que você possa acessar seu dispositivo pelo Browser digitando o nome deste dispositivo na barra de endereços.
É na próxima tela que você configurará o endereço IP de seu projeto, nome do dispositivo, máscara de sub-rede, endereço MAC, etc...

Configure de forma que o dispositivo seja reconhecido em sua rede. Assim que isto for feito, clique em Next, e você será perguntado sobre qual biblioteca HTTP você pretende usar em seu projeto.

Vamos usar o HTTP2, pois ele traz inúmeras vantagens, como a possibilidade de usar métodos POST em formulários e o uso de variáveis dinâmicas. Feito isto, na próxima tela temos a seleção de configurações da biblioteca:

Como é um teste simples, vamos habilitar apenas os métodos POST. A página inicial será a página index.htm, e permitiremos apenas duas conecções por vez. Na próxima tela temos a seleção do sistema de arquivos, mas o HTTP2 da Microchip possibilita apenas o uso do sistema de arquivos MPFS2. Depois desta seleção, podemos escolher onde os arquivos serão gravados. No meu projeto, preferi salvar os arquivos dentro da Flash de programa do microcontrolador, que tinha espaço suficiente para todos os arquivos. Outras opções são:

O próximo passo é o mais complicado. Neste passo, você determinará a quantidade de memória usada para cada conecção.

Como não usamos nenhum outro tipo de conecção, determinaremos memória apenas para o HTTP_SERVER. Verifique se os outros tipos de Sockets estão com seu Count diferente de 0. O Count determina quantas conecções daquele tipo existirão. Como só temos duas conecções HTTP, só neste tipo de Socket é que deveremos ter um valor diferente de 0. A próxima tela permite você escolher quantas conecções UDP sua aplicação terá, e finalmente você poderá concluir esta configuração. O programa vai sobreescrever os valores disponíveis no seu arquivo TCPIPConfig.h. Estamos prontos para dar início a nosso projeto.

Arquivo principal do projeto

O arquivo principal do projeto deverá seguir alguns procedimentos básicos. O primeiro é que ele deve trazer a seguinte definição:

#define THIS_IS_STACK_APPLICATION

Isto indicará ao compilador qual é o arquivo principal. O segundo passo é que sua aplicação deverá definir uma instância da estrutura APP_CONFIG chamada de AppConfig. Esta estrutura contém as configurações de TCP/IP do projeto. Adicione a linha:

APP_CONFIG AppConfig;

Esta será uma variável global.
Nós temos também que definir o tratamento de interrupções de tempo, pois o Stack TCP/IP da Microchip usa os timers para o gerador de ticks. O tratamento de interrupção pode ser feito através do seguinte código:

#pragma interruptlow LowISR
void LowISR(void)
{
 TickUpdate();
}
 
#pragma interruptlow HighISR
void HighISR(void)
{
}
 
#pragma code lowVector=0x18
void LowVector(void){_asm goto LowISR _endasm}
#pragma code highVector=0x8
void HighVector(void){_asm goto HighISR _endasm}
#pragma code // Volta para a seção padrão de código

Para um servidor HTTP, as funções de tratamento de mensagens GET e POST (quando habilitadas) serão chamadas. Mas as bibliotecas da Microchip deixam a definição destas funções a cargo da aplicação, para que o programador trate destas mensagens da forma que ele deseja. Como estamos no início do projeto e a intenção é apenas gerar um servidor sem formulários no começo, vamos definir funções que não fazem nenhum tratamento:

HTTP_IO_RESULT HTTPExecuteGet(void)
{
  return HTTP_IO_DONE;
}

HTTP_IO_RESULT HTTPExecutePost(void) 
{
  return HTTP_IO_DONE;
}

Retornando HTTP_IO_DONE em ambas funções, dizemos às bibliotecas TCP/IP da microchip que o tratamento destas funções foi bem-sucedido, o que não deixa de ser verdade.
Como antes criamos uma instância da estrutura APP_CONFIG, precisamos agora preenchê-la com os dados necessários à aplicação. Os detalhes desta função podem ser vistos no programa de demonstração da Microchip, mas para facilitar esta tarefa, estarei colocando a função que criei aqui:

static ROM BYTE SerializedMACAddress[6] = {MY_DEFAULT_MAC_BYTE1, MY_DEFAULT_MAC_BYTE2, MY_DEFAULT_MAC_BYTE3, MY_DEFAULT_MAC_BYTE4, MY_DEFAULT_MAC_BYTE5, MY_DEFAULT_MAC_BYTE6};

static void InitAppConfig(void)
{
 AppConfig.Flags.bIsDHCPEnabled = TRUE;
 AppConfig.Flags.bInConfigMode = TRUE;
 memcpypgm2ram((void*)&AppConfig.MyMACAddr, (ROM void*)SerializedMACAddress, sizeof(AppConfig.MyMACAddr));
 AppConfig.MyIPAddr.Val = MY_DEFAULT_IP_ADDR_BYTE1 |  MY_DEFAULT_IP_ADDR_BYTE2<<8ul | MY_DEFAULT_IP_ADDR_BYTE3<<16ul | MY_DEFAULT_IP_ADDR_BYTE4<<24ul; AppConfig.DefaultIPAddr.Val = AppConfig.MyIPAddr.Val; AppConfig.MyMask.Val = MY_DEFAULT_MASK_BYTE1 | MY_DEFAULT_MASK_BYTE2<<8ul | MY_DEFAULT_MASK_BYTE3<<16ul | MY_DEFAULT_MASK_BYTE4<<24ul; AppConfig.DefaultMask.Val = AppConfig.MyMask.Val; AppConfig.MyGateway.Val = MY_DEFAULT_GATE_BYTE1 | MY_DEFAULT_GATE_BYTE2<<8ul | MY_DEFAULT_GATE_BYTE3<<16ul | MY_DEFAULT_GATE_BYTE4<<24ul; AppConfig.PrimaryDNSServer.Val = MY_DEFAULT_PRIMARY_DNS_BYTE1 | MY_DEFAULT_PRIMARY_DNS_BYTE2<<8ul | MY_DEFAULT_PRIMARY_DNS_BYTE3<<16ul | MY_DEFAULT_PRIMARY_DNS_BYTE4<<24ul; AppConfig.SecondaryDNSServer.Val = MY_DEFAULT_SECONDARY_DNS_BYTE1 | MY_DEFAULT_SECONDARY_DNS_BYTE2<<8ul | MY_DEFAULT_SECONDARY_DNS_BYTE3<<16ul | MY_DEFAULT_SECONDARY_DNS_BYTE4<<24ul; memcpypgm2ram(AppConfig.NetBIOSName, (ROM void*)MY_DEFAULT_HOST_NAME, 16); FormatNetBIOSName(AppConfig.NetBIOSName);
}

Por fim, nossa função main. Aqui há algumas observações a se fazer... As funções de inicialização do protocolo devem seguir uma ordem para serem executadas, pois do contrário o nosso servidor não funcionará. A ordem é a seguinte:

InitAppConfig();
TickInit();
MPFSInit();
StackInit();

O loop principal de seu programa deve executar estas duas funções:

StackTask();
StackApplications();

São estas as funções que devem ser usadas no seu projeto.

Configurando o projeto

Devemos incluir os arquivos para o projeto. Antes disto, devemos configurar o projeto para que inclua os cabeçalhos da Microchip na hora de compilar. Vamos ao menu Project, Build Options... Em Directories, clicando no menu Drop Down, selecionamos a opção Include Search Path. Vamos incluir aqui o diretório do projeto ".", o diretório de includes da Microchip Solutions, e o diretório de includes do C18. Em Library Search Path incluiremos também o diretório de livrarias do C18. Feito isto, estamos prontos para incluir os arquivos do projeto.
Para compilar o projeto, precisamos incluir os seguintes arquivos: ARP.c, Delay.c, DNS.c, ENC28J60.c, Helpers.c, HTTP2.c, ICMP.c, IP.c, MPFS2.c, NBNS.c, StackTsk.c, TCP.c, Tick.c, UDP.c. Agora nos resta criar os arquivos html para o servidor web.

Arquivos do servidor

Na sua pasta de projeto, crie uma pasta para guardar os arquivos html do servidor. É importante criar o arquivo index.htm que nós colocamos antes como o arquivo inicial do servidor. Neste primeiro passo, vamos criar apenas arquivos estáticos.
Assim que os arquivos forem criados, poderemos voltar na pasta Utilities onde encontramos o executável de configuração de TCP/IP. Agora vamos executar o programa MPFS2.exe.

Este programa irá converter os arquivos da pasta que você indicar para o sistema de arquivos MPFS. Como desejamos gravar na memória de programa do PIC, iremos converter nossos arquivos em um arquivo .c, que deverá ser incluído também no projeto. Assim que você clicar Generate, dois arquivos serão criados na pasta de projeto que você especificou. Depois disto, inclua o arquivo HTTPPrint.h que o programa gerar.
Pronto! Nosso projeto está completo e poderá ser compilado.

Voltaremos a falar sobre este tema posteriormente, explicando como usar formulários e variáveis dinâmicas. Por fim, ensinaremos a usar AJAX com nosso servidor web.