sexta-feira, 24 de janeiro de 2014

Servidor web com o modulo WIZ820 usando o ATmega328:

    Olá hoje vou demonstrar como fazer um servidor web com o modulo WIZ820 para este projeto montei uma fonte que transforma 12V em 3,3V(pois o wiznet  funciona com essa tensão)e assim o circuito funciona em 3,3V.Para montar a fonte recorri ao circuito integrado MC33063.
    Na figura abaixo é mostrado o aparência do modulo wiz820: 





O esquemático:


O Código fonte:


//***********************************************************************************************************
//                               Usando o modulo wiz820io
//
// no gravador configurar os fuses assim:
//  EXTENDED 0XFF 
//  HIGH     0XD8 - neste modo funciona com qualquer valor de cristal usei um de 16Mhz  
//  LOW      0XC7
//  LOKBITS  0XFF  - sem proteção
//
//
//  versão                        : 1
//  descrição                   : Servidor web com o modulo modulo wiz820
//  Autor                      : Aguivone
//  microcontrolador           : ATmega328P
//  compilador                   : AVR-GCC / Atmel AVR Studio 4.17
//  Data do projeto            : 24 / 01 / 2014 
//  aviso! - no modulo wiz 820 deve ser colocado um capacitor de 100nF no pino de reset para evitar problemas de ruido
//*************************************************************************************************************
#include <avr/io.h>
#include <string.h>
#include <stdio.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>// AVRJazz Mega328 SPI I/O

////////////////////////funçoes auxiliares/////////////////////////////
#define liga_pino(x,y) x |= _BV(y)
#define desliga_pino(x,y) x &= ~(_BV(y))

/////////////////////////////////////////////////////////////////////////////////////////////
//configuração dos pinos SPI
#define SPI_PORT PORTB //porta que será usado para SPI
#define SPI_DDR  DDRB  
#define SPI_SS   PORTB2//seleção de chip(habilita comunicação SPI)



// Wiznet W5200 endereço dos registradores
#define MR         0x0000   // Registrador de modo
#define GAR           0x0001   // endereço(inicial) de Gateway : 0x0001 a 0x0004
#define SUBR       0x0005   // mascara de subrede           : 0x0005 a 0x0008
#define SHAR       0x0009   // Source Address Register , endereço de hardware (MAC)   : 0x0009 a 0x000E
#define SIPR       0x000F   // IP do hardware(escolhido pelo programador): 0x000F to 0x0012 //Socket 0

///aqui houve alteração em relação ao wiz810
#define RMSR       0x401E   // RX - localização do buffer de recepção
#define TMSR       0x401F   // TX - localização do buffer de envio

/////////////////configurei apenas o sockt0 pois vou usar apenas este.///////////////
/*
para colocar mais socket 2 por exemplo (0X4n00)
S0_PORT  0X4204
lembre que agora os buffer de rx e tx mudaram uma vez que o wiz820 tem capacidade para até 7 sockets
*/


#define S0_MR       0x4000      // Socket 0: registrador do socket0 
#define S0_CR       0x4001      // Socket 0: registrador de comandos do socket0
#define S0_IR       0x4002      // Socket 0: registrador de interrupçoes do socket0
#define S0_SR       0x4003      // Socket 0: registrador de status do socket0
#define S0_PORT    0x4004      // Socket 0: aqui é colocado o valor da porta TCP ->  endereço = 0x0404 a 0x0405
#define S0_DPORT   0x4010      // Socket 0: aqui é colocado o valor da porta TCP de destino->  endereço = 0x0410 a 0x0411
#define S0_DHAR    0x4006      // Socket 0: endereçamento de registro de hardware(tipo MAC)->  endereço = 0x0406 a 0x040B
#define S0_DIPR    0x400C      // Socket 0: IP de acesso remoto ->  endereço = 0x040C a 0x040F
#define SO_TX_FSR  0x4020      // Socket 0: tamanho do registrador de transmissão: 0x0420 to 0x0421
#define S0_TX_RD   0x4022      // Socket 0: ponteiro de leitura do buffer de transmissão : 0x0422 a 0x0423
#define S0_TX_WR   0x4024      // Socket 0: ponteiro de escrita do buffer de transmissão: 0x0424 a 0x0425
#define S0_RX_RSR  0x4026      // Socket 0: tamanho do registrador de recepção: 0x0426 a 0x0427
#define S0_RX_RD   0x4028      // Socket 0: ponteiro de leitura do tamanho dos dados: 0x0428 a 0x0429
#define S0_IMR       0x402C      // mascara de interrupção dos sockets
#define S0_RTR       0x0017      // timeout
#define S0_RCR       0x0019      // timeout

//////////////////endereços de escrita e recepção //////////////////////

#define TXBUFADDR  0x8000      // W5200 posição inicial do buffer de escrita
#define RXBUFADDR  0xC000      // W5200 posição inicial do buffer de recepção

////////////comando do chip////////////////////////////////////////////

//S0_MR (possiveis configuração)
#define MR_CLOSE      0x00    // socket não usado
#define MR_TCP          0x01    // TCP
#define MR_UDP          0x02    // UDP
#define MR_IPRAW      0x03      // IP LAYER RAW SOCKET
#define MR_MACRAW      0x04      // MAC LAYER RAW SOCKET
#define MR_PPPOE      0x05      // PPPoE
#define MR_ND          0x20      // sem delay de Ack(somente TCP) 
#define MR_MULTI      0x80      // suporte ao multicast(valido somente para UDP)
// S0_CR values
#define CR_OPEN          0x01      // Initializa ou abre socket
#define CR_LISTEN        0x02      // espera resposta de um ponto na rede (no modo tcp(modo servidor))
#define CR_CONNECT       0x04      // envia resposta a um ponto da rede(modo cliente)
#define CR_DISCON        0x08      // finaliza conexão e gera interrupção se falhar(desconexão)
#define CR_CLOSE         0x10      // desconecta socket
#define CR_SEND          0x20      // atualiza memoria de transmissão e envia dados
#define CR_SEND_MAC      0x21      // envia dados com o endereço do MAC, sem o processo ARP(modo UDP)
#define CR_SEND_KEEP     0x22      // ckeca estado da conexão - envia um byte pra testar a conexão (modo tcp)
#define CR_RECV          0x40      // indica uma recepção no socket
// S0_SR values
#define SOCK_CLOSED      0x00     // socket fechado
#define SOCK_INIT        0x13      // inicializa conexão
#define SOCK_LISTEN      0x14      // verifica estado(listen)
#define SOCK_SYNSENT     0x15      // comando de conexão foi iniciado
#define SOCK_SYNRECV     0x16      // houve sincronismo de recepção
#define SOCK_ESTABLISHED 0x17      // sucesso na conexão
#define SOCK_FIN_WAIT    0x18      // esperando finalizar
#define SOCK_CLOSING     0x1A      // finalizando conexão
#define SOCK_TIME_WAIT     0x1B      // espera tempo para finaliza
#define SOCK_CLOSE_WAIT  0x1C      // recebeu comando de fechar pelo host
#define SOCK_LAST_ACK    0x1D      // durante a finalização é o ultimo ack
#define SOCK_UDP         0x22      // UDP     socket
#define SOCK_IPRAW       0x32      // IP raw  socket
#define SOCK_MACRAW      0x42      // MAC raw socket
#define SOCK_PPPOE       0x5F      // PPPOE   socket
#define TX_BUF_MASK      0x0FFF   // Mascara do buffer de transmissão 4K para o socket0(4096 - 1 = 4095 = 0X0FFF)
#define RX_BUF_MASK      0x0FFF   // Mascara do buffer de recepção 4K para o socket0(4096 - 1 = 4095 = 0X0FFF)
#define NET_MEMORIA      0x04     // Use 4K de Tx/Rx Buffer(pode se usar até 16K)
#define TCP_PORT         80       // porta TCP/IP usada pelo modulo
#define MAX_BUF          20      // tamanho maximo do buffer de recepção reduzi de 100 pra 20
/////////
//////// variaveis globais ////////////////////////////////////////
////////
uint8_t buf[MAX_BUF];
uint8_t sockstat;
uint16_t rsize;
int get_pos;
char radiostat0[10],radiostat1[10];
unsigned char temp[2];//usado para passar os defines - variavel auxiliar

/////////variaveis da serial///////////////////////
 unsigned char caracter;//
 unsigned int  tam_buffer;//usado para contar o tamanho do buffer de recepção
 unsigned char buffer_serial[14];//buffer da serial
 volatile char rec_buffer ='S';//usado para ler o buffer de recepção (volatile para funcionar pois sempre ira retornar mesmo valor)


void inicializa_spi(void)
{
// Seta MOSI (PORTB3),SCK (PORTB5) and PORTB2 (SS) , e os outros pinos como saida 
  SPI_DDR = (1<<PORTB3)|(1<<PORTB5)|(1<<PORTB2)|(1<<PORTB1);//coloca b1 como saida
  // SS não ativado
  SPI_PORT |= (1<<SPI_SS); 
  // habilita SPI, modo mestre 0, seta clock para fck/2
  SPCR = (1<<SPE)|(1<<MSTR);
  SPSR |= (1<<SPI2X);  
}
///////////////////////função de escrita SPI////////////////////////

void spi_escreve(unsigned int endereco,unsigned char *dados,unsigned int tamanho)
{
  // ativa pino de habilitação do SPI
  SPI_PORT &= ~(1<<SPI_SS); 
  //******************** endereço ************************
  // escreve bytes mais significativo no buffer spi
  SPDR = (endereco & 0xFF00) >> 8;
   // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF))); 
   //escreve os bytes menos significativo no buffer spi
  SPDR = endereco & 0x00FF;  
  // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF)));   
  //******************** Opcode + tamanho dos dados************************
   SPDR = ((0X80)|((tamanho & 0xFF00) >> 8));//indica que vai escrever(opcode)
   // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF))); 
   //escreve os bytes menos significativo no buffer spi
  SPDR = tamanho & 0x00FF;
  // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF)));
  unsigned int contagem=0;
  while(contagem<tamanho)
  { 
      SPDR = dados[contagem];  // inicializa transmissão de dados
      while(!(SPSR & (1<<SPIF))); // espera finalizar a transmissão
      // finaliza comunicação.
      contagem++;
  }
  SPI_PORT |= (1<<SPI_SS);
}
/////////////////////////de leitura////////////////////////////////


unsigned char spi_ler(unsigned int endereco)
{
// ativa pino de habilitação do SPI
  SPI_PORT &= ~(1<<SPI_SS); 
  //******************** endereço ************************
  // escreve bytes mais significativo no buffer spi
  SPDR = (endereco & 0xFF00) >> 8;
   // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF))); 
   //escreve os bytes menos significativo no buffer spi
  SPDR = endereco & 0x00FF;  
  // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF)));   
  //******************** Opcode + tamanho dos dados************************
  //aqui vou sempre receber 1 byte de dados, embora é possivel enviar mais
  // escreve bytes mais significativo no buffer spi
  SPDR = 0X00;
   // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF))); 
   //escreve os bytes menos significativo no buffer spi
  SPDR = 0X01;//seta para receber apenas 1 byte  
  // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF))); 
  // envia um valor qualquer para ler os dados(pois isto liga o sinal de clock do registrado SPI)
  SPDR = 0x00;
  // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF))); 
  // finaliza comunicação.
  SPI_PORT |= (1<<SPI_SS);
  return(SPDR);//retorna o valor lido do W5200
}


////////////////////////inicializa ethernet //////////////////////////////////
void W5200_Inicializa(void)
{
 unsigned char porta[] = {0x00,0X50};// ex PORTA 80 = 0X0050 -> 0X00 +0X50 //porta 80
  // esse mac é do AA0000 dezembro obsoleto
   unsigned char mac_addr[] = {0xAA,0x00,0x00,0xFF,0xFF,0x88};//MAC usado pelo microcontrolador(para teste)
  //dois dispositivos na mesma rede não pode ter o mesmo mac, coloquei o mais alto como padrão
  //aqui usei o ip para alterar o mac assim como em cada conexão não pode haver o mesmo ip ,tambem não haverá o mesmo mac
  unsigned char ip_addr[] = {192,168,0,5};//endereço de ip do servidor(valor para teste,do microcontrolador)
  unsigned char sub_mask[] = {255,255,255,0};//sem mascara mascara de sub_rede
  unsigned char gtw_addr[] = {192,168,0,254};//enderreço de ip do gateway cliente (valor para teste,do pc)
  //este ip não é necessariamente o do pc mas deve estar nesta faixa
  unsigned char ip_dipr[] = {192,168,0,5};
  temp[0] = 0X80;
  spi_escreve(MR, temp,1);            // MR = 0b10000000; isso inicicializa os registradores internos automaticamente
  _delay_ms(1);
  temp[0] = 0X03;//numero de retransmissão
  spi_escreve(S0_RCR,temp,1);            // desabilita todas as interrupções do W5200
  _delay_ms(1);
  temp[0] = 0X00;
  spi_escreve(S0_IMR,temp,1);            // desabilita todas as interrupções do W5200
  _delay_ms(1);
   temp[0] = 0X07;
  temp[1] = 0XD0;//timeouto para 200ms(por padrão é 100us)
   spi_escreve(S0_RTR,temp,2);            // desabilita todas as interrupções do W5200
  _delay_ms(1);
  //configura porta de comunicação para acesso remoto
  spi_escreve(S0_PORT , porta,2);
   _delay_ms(1);
  spi_escreve(S0_DPORT , porta,2);
  temp[0] = MR_TCP;//conf. para TCP
  spi_escreve(S0_MR,temp,1);    // configura o registrador de modo (MR)
  _delay_ms(1);
  // configura o MAC de acesso remoto
  spi_escreve(S0_DHAR , mac_addr,6);
 // _delay_ms(1);
    // configura o MAC (SHAR): 0x0009 à 0x000E
  spi_escreve(SHAR ,mac_addr,6);
  _delay_ms(1);
  // endereço de IP de acesso remoto será sempre 1 na ultima casa
  spi_escreve(S0_DIPR,ip_dipr,4);
  _delay_ms(1);
  //configura gateway do cliente
  spi_escreve(GAR ,gtw_addr,4);
  _delay_ms(1);
  // mascara de sub rede (SUBR): 0x0005 à 0x0008
  spi_escreve(SUBR ,sub_mask,4);
  _delay_ms(1);
  // endereço de IP (SIPR): 0x000F à 0x0012
  spi_escreve(SIPR,ip_addr,4);
  _delay_ms(1);
  // configura o tamanho do buffer  de memoria de escrita e leitura 
  temp[0] = NET_MEMORIA;
  spi_escreve(RMSR,temp,1);//configura para cada socket 2K de memoria de leitura(no W5200 tem 8 socket mas vamos usar somente o socket 0)
  _delay_ms(1);
  spi_escreve(TMSR,temp,1);//configura para cada socket 2K de memoria de transmissao(no W5200 tem 8 socket mas vamos usar somente o socket 0)
  _delay_ms(1);
}
//////////////////////////////////fecha socket 0  ///////////////////////
void fechar_socket(uint8_t socket)
{
   if (socket != 0)return;
   // manda fechar
   temp[0] = CR_CLOSE;
   spi_escreve(S0_CR,temp,1);   // espera que S0_CR seja zerado(finalizado)
   while(spi_ler(S0_CR));
}

//////////////////////////////////fecha conexão//////////////////////////
void desconectar(uint8_t sock)
{
   if (sock != 0) return;   // envia comando para desconectar
   temp[0] = CR_DISCON;
   spi_escreve(S0_CR,temp,1);   // espera desconexão.
   while(spi_ler(S0_CR));
}
////////////////////////////////conecta pelo modo servidor////////////////////
uint8_t conex_servidor(uint8_t socket)
{
    uint8_t retval=0;   
     if (socket != 0)//teste socket0
      return retval;
     if (spi_ler(S0_SR) == SOCK_CLOSED) // verificando se o socket 0 está fechado.
      {
      fechar_socket(socket);
      }     
    // abrindo o  Socket 0
    temp[0]=CR_OPEN;
    spi_escreve(S0_CR,temp,1);                   // abre socket 
    while(spi_ler(S0_CR)); //espera abrir  
    if (spi_ler(S0_SR) == SOCK_INIT)//checa estado inicial
      retval=1;
    else
      fechar_socket(socket);
    return retval;
}

/////////////////////////////"escuta" a rede/////////////////////////////////
uint8_t escutar_rede(uint8_t socket)
{
     uint8_t retval = 0;
     if (socket != 0)
     return retval;
     if (spi_ler(S0_SR) == SOCK_INIT) 
     { 
         temp[0]=CR_LISTEN;
         spi_escreve(S0_CR,temp,1);//envia comando para escutar a rede
         while(spi_ler(S0_CR));     // espera terninar processo de escuta
         if (spi_ler(S0_SR) == SOCK_LISTEN) //verifica status de escuta
           retval=1;
         else
           fechar_socket(socket);
     }
    return retval;
}

////////////////////////////envia pacote////////////////////////////////////
uint16_t envia_pacote(unsigned char *frase,uint16_t buffer_tamanho)
{
      unsigned int ponteiro,ende_temp,ende_real,tx_tamanho,timeout;   

    if (buffer_tamanho <= 0 )return 0;//verifica se tem espaço livre para transmitir
    tx_tamanho=spi_ler(SO_TX_FSR);
    tx_tamanho=(((tx_tamanho & 0x00FF) << 8 ) + spi_ler(SO_TX_FSR + 1));//calcula tamanho do buffer de transmissão.
    timeout=0;
    while (tx_tamanho < buffer_tamanho) 
    {
          _delay_us(500);//0.5ms
         tx_tamanho= spi_ler(SO_TX_FSR);
         tx_tamanho=(((tx_tamanho & 0x00FF) << 8 ) + spi_ler(SO_TX_FSR + 1));     // Timeout para aproximadamente 5ms
         if (timeout++ > 10) 
           {
            // desconecta socket 0 pois não há espaço livre após 10ms
           desconectar(0);
           return 0;
           }
    }
    tx_tamanho=0;    
   ponteiro = spi_ler(S0_TX_WR);//lê o ponteiro de escrita.
   ende_temp = (((ponteiro & 0x00FF) << 8 ) + spi_ler(S0_TX_WR + 1));
    while(buffer_tamanho>0) 
    {
      buffer_tamanho--;
      // calcula o endereço real do buffer de transmissão. 
      ende_real = TXBUFADDR + (ende_temp & TX_BUF_MASK);      // copia pacote para W5200(TX_buffer)
      temp[0] = frase[tx_tamanho]; 
      spi_escreve(ende_real,temp,1);
      ende_temp++;
      tx_tamanho++;
    }
    // incrementa valor de  S0_TX_WR , então este será o ponto da proxima transmissão
    temp[0]=( ende_temp & 0xFF00) >> 8;
    temp[1]= ende_temp & 0x00FF;
    spi_escreve(S0_TX_WR,temp,2);
    // agora envia o comando de enviar dados para rede.
    temp[0] = CR_SEND;
    spi_escreve(S0_CR,temp,1);
    // espera terminar o envio
    while(spi_ler(S0_CR));
    return 1;
}
/////////////////////////////////recebe pacote//////////////////////////////////////////
void recebe_pacote(uint8_t *pacote)
{
        unsigned int conta=0,buffer_tamanho = MAX_BUF-2;
        char FIM[9]={'H','T','T','P','/','1','.','1'};
        unsigned int ponteiro,ende_temp,ende_real;  
             
        ponteiro = spi_ler(S0_RX_RD);//pega localização do dado recebido(tamanho)
        ende_temp = (((ponteiro & 0x00FF) << 8 ) + spi_ler(S0_RX_RD + 1));////pega localização do dado recebido por ser 16 bits "ponteiro" deve ser descolado 
        while((buffer_tamanho) && (conta<8)) 
        {
          buffer_tamanho--;
          ende_real=RXBUFADDR + (ende_temp & RX_BUF_MASK);//endereço inicial de leitura + endereço dos dados recebidos 
          *pacote = spi_ler(ende_real);
          //put_serial(*pacote);
           if(FIM[conta] == spi_ler(ende_real))
           {
            conta++;
           }else
           {
            conta=0;
           }
          ende_temp++;
          pacote++;
                     
        }
    *pacote='\0';        // String de fim de pacote
    // incrementa S0_RX_RD ,este será o ponto da proxima recepção
    temp[0]=(ende_temp & 0xFF00) >> 8;
    temp[1]= ende_temp & 0x00FF;
    spi_escreve(S0_RX_RD,temp,2);
    //envia comando para leitura 
    temp[0]=CR_RECV;
    spi_escreve(S0_CR,temp,1);
    _delay_us(5);    // espera terminar leitura.                    
}
///////////////////////////////////////////////////////////////////////
uint16_t tamanho_recepcao(void)
{
  return (((spi_ler(S0_RX_RSR) & 0x00FF) << 8 ) + spi_ler(S0_RX_RSR + 1)); //
}
////////////////////////////////////////////////////////////////////////
int string_index(char *str_de_teste,char *str_compara)//procura posição de uma string
{
  uint16_t i,str_tamanho;

  str_tamanho=strlen(str_compara);// pega tamanho da string
  for(i=0;*(str_de_teste+i); i++)//percorre o ponteiro 
  {
    if (strncmp(str_de_teste+i,str_compara,str_tamanho) == 0)//compara com str_compara  
      return i;
  }
  return -1;
}
/*8 void limpa_buffer(void)
{
   int16_t temp=MAX_BUF-1;
   while(temp>0)
   {
    buf[temp]='\0';
   }
}*/

int envia_pagina(void)
{
 int flag=0;
                                    // criando pagina HTTP de resposta 
                                    strcpy_P((char *)buf,PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\n"));
                                    strcat_P((char *)buf,PSTR("<html><body><span style=\"color:#0000A0\">\r\n"));
                                    strcat_P((char *)buf,PSTR("<h1>PROGRAMA DE TESTE</h1>\r\n"));
                                    strcat_P((char *)buf,PSTR("<h2>MICROCONTROLADORES-C</h2>\r\n"));
                                    strcat_P((char *)buf,PSTR("<p><form method=\"GET\">\r\n"));//POST

                                    // cria resposta do botao HTTP
                                    strcat_P((char *)buf,PSTR("<p><input type=\"radio\" name=\"Bot\" value=\"0\" "));
                                    strcat((char *)buf,radiostat0);
                                    strcat_P((char *)buf,PSTR(">Desligar led. \r\n"));
                                    strcat_P((char *)buf,PSTR("<br><input type=\"radio\" name=\"Bot\" value=\"1\" "));
                                    strcat((char *)buf,radiostat1);
                                    strcat_P((char *)buf,PSTR(">Ligar led. \r\n"));

                                    strcat_P((char *)buf,PSTR("</strong><p>\r\n"));
                                    strcat_P((char *)buf,PSTR(" \r\n <input type=\"submit\"  value=\"Enviar\"> \r\n"));
                                    strcat_P((char *)buf,PSTR("</form></span></body></html>\r\n"));//finaliza pagina 
                                    // // enviando pagina HTTP de resposta do botao
                                    if (envia_pacote(buf,strlen((char *)buf)) <= 0)//socket 0 ,envia o vetor buf,coloca o tamanho do vetor
                                    flag=1;
                                    return(flag);
}
////////////////////função principal/////////////////////////////////////
int main(void)
 {
  
  //////////////////inicializa port D /////////////////////////////////////////////////////////////////////
    DDRD = 0xFE;       // Seta PORTD como saida exceto a entrada serial
    PORTD = 0x00;
    DIDR0 = 0X00;////desabilita entrada analogico(reduz consumo).evita problemas quando esse pino é usado como saida 
    DDRB = 0x2F;//configura port B
    inicializa_spi();    //comunicação spi         
    rsize = 0;
    liga_pino(PORTB,PB1);//led
    desliga_pino(PORTB,PB0);///// //reseta o chip de ethernet - para garantir uma conexão segura
    _delay_ms(10);//tempo de reset
    liga_pino(PORTB,PB0);
    _delay_ms(150);//nessecessario para o modulo se preparar
    W5200_Inicializa();  //ethernet
    ///////////////////////////////////
    sei();
    desliga_pino(PORTB,PB1);//led
///////////////////////////////////////////////////////
  for(;;)
    {       sockstat=spi_ler(S0_SR);
            switch(sockstat) 
            {
             case SOCK_CLOSED: ///socket fechado.
                if ( conex_servidor(0) > 0) 
                     {// escuta  Socket 0
                        if (escutar_rede(0) <= 0)//socket 0
                             _delay_ms(1);
                     }break;   
             case SOCK_ESTABLISHED://conectado
                 {
                  // pega o tamanho do pacote recebido do cliente
                  rsize=((spi_ler(S0_RX_RSR) & 0x00FF) << 8 ) + spi_ler(S0_RX_RSR + 1);//pega tamanho dos dados recebido
                  if (rsize > 0)//isso indica que o pacote é maior que zero
                     {
                      // lê o pacote recebido
                          recebe_pacote(buf);                        
                           // Check the Request Header
                           get_pos=string_index((char *)buf,"GET /");//procura pela posição da string "GET /"
                              if (get_pos >= 0 )
                                 {
                                  // ckeca botão do codigo html
                                         
                                            if (string_index((char *)buf,"Bot=0") > 0)//procura pela posição da string "radio=0"
                                                         { 
                                                         desliga_pino(PORTB,PB1);//led
                                                         strcpy_P(radiostat0,PSTR("checked"));
                                                         strcpy(radiostat1,"");
                                                         }
                                             if (string_index((char *)buf,"Bot=1") > 0)//procura pela posição da string "radio=1"
                                                         {
                                                          liga_pino(PORTB,PB1);//led
                                                          strcpy(radiostat0,"");
                                                          strcpy_P(radiostat1,PSTR("checked"));
                                                  
                                                         }                                            
                                      if(envia_pagina()==1)//se falhar sai da conexão
                                      break;
                                         // atualiza estado dos botoes   
                                 }//fim do getpos                            
                             desconectar(0);// desconecta socket 0
                    }
              else
                    {
                      _delay_us(10);    //perde tempo para espera resposta
                    }
              }break;      
              case SOCK_FIN_WAIT:
              case SOCK_CLOSING:
              case SOCK_TIME_WAIT:
              case SOCK_CLOSE_WAIT:
              case SOCK_LAST_ACK:
              fechar_socket(0);// força o fechamento do socket 0
              break;
      }//chave do switch
   }//chave do laço infinito (for)
}//chave de main

A aplicação rodando ficou assim via navegador do chrome:

Veja como ficou o protótipo:




3 comentários :

  1. Gostei muito do projeto. Vou tentar implementa-la.

    ResponderExcluir
  2. Olá. Você tem este hardware pronto para vender? Se não, sabe onde posso conseguir? Obrigado.

    ResponderExcluir
    Respostas
    1. Me mande um e-mail para aguivone@ibest.com.br ou vc pode comprar somente o modulo na hitech.

      Excluir

olá,digite aqui seu comentário!