segunda-feira, 15 de outubro de 2012

Interface Ethernet com o ATmega328 (2)

Olá a todos que seguem meu blog hoje vou ensinar como estabelecer uma conexão Ethernet com o microcontrolador ATmega328,pra quem não viu em postagens anteriores coloquei um exemplo onde ele se comunica via modulo "wiz 810" fornecido aqui no brasil pela hitech, neste exemplo vou fazer a interface com o pc sem usar uma pagina html(como foi feito no primeiro exemplo),com isso se economiza memoria do microcontrolador.
 O primeiro passo é configurar a porta de rede de seu pc(como no meu pc tenho 2 portas eu fiz o seguinte; uma é a que me conecto a internet e a outra deixei para acessar minha placa) vale lembra que no exemplo eu uso a porta 5000 e o IP da placa é 192.168.0.5,mas no pc deve ficar assim:
isso pode ser acessado por meus locais de rede->exibir conexões de rede então clicando duas vezes abrirá uma janela pra configurar a porta Ethernet  indo na aba geral protocolo TCP/IP tem se acesso a propriedades de protocolo, deixe como na figura acima.

O código fonte :

//***********************************************************************************************************
//                             ethernet exemplo de uso para interface com pc
//  versão                        : 1.0
//  descrição                   : Enviando e recebendo dados pela ethernet
//  Autor                      : Aguivone
//  microcontrolador           : ATmega328 P
//  compilador                   : AVR-GCC / Atmel AVR Studio 4.17
//  Data do projeto            : 15 / 02 / 2012 - inicio.

//*************************************************************************************************************
#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))
#define alterna_pino(x,y) x ^= _BV(y)
#define estado_pino(x,y) ((x & _BV(y)) == _BV(y)) //o pino deve estar como entrada ,testa se está em nivel logico 1
/////////////////////////////////////////////////////////////////////////////////////////////
//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 W5100 Op Code usados
#define WIZNET_ESCREVE_OPCODE 0xF0  
#define WIZNET_LER_OPCODE     0x0F
// Wiznet W5100 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 SAR           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
#define RMSR       0x001A   // RX tamanho do buffer(memória) de recepção
#define TMSR       0x001B   // TX tamanho do buffer(memória) de envio

#define S0_MR       0x0400      // Socket 0: registrador do socket0 
#define S0_CR       0x0401      // Socket 0: registrador de comandos do socket0
#define S0_IR       0x0402      // Socket 0: registrador de interrupçoes do socket0
#define S0_SR       0x0403      // Socket 0: registrador de status do socket0
#define S0_PORT    0x0404      // Socket 0: aqui é colocado o valor da porta TCP ->  endereço = 0x0404 a 0x0405
#define S0_DPORT   0x0410      // Socket 0: aqui é colocado o valor da porta TCP de destino->  endereço = 0x0410 a 0x0411
#define S0_DHAR    0x0406      // Socket 0: endereçamento de registro de hardware(tipo MAC)->  endereço = 0x0406 a 0x040B
#define S0_DIPR    0x040C      // Socket 0: IP de acesso remoto ->  endereço = 0x040C a 0x040F
#define SO_TX_FSR  0x0420      // Socket 0: tamanho do registrador de transmissão: 0x0420 to 0x0421
#define S0_TX_RD   0x0422      // Socket 0: ponteiro de leitura do buffer de transmissão : 0x0422 a 0x0423
#define S0_TX_WR   0x0424      // Socket 0: ponteiro de escrita do buffer de transmissão: 0x0424 a 0x0425
#define S0_RX_RSR  0x0426      // Socket 0: tamanho do registrador de recepção: 0x0426 a 0x0427
#define S0_RX_RD   0x0428      // Socket 0: ponteiro de leitura do tamanho dos dados: 0x0428 a 0x0429

#define TXBUFADDR  0x4000      // W5100 posição inicial do buffer de escrita
#define RXBUFADDR  0x6000      // W5100 posição inicial do buffer de recepção
//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      0x07FF   // Mascara do buffer de transmissão 2K :
#define RX_BUF_MASK      0x07FF   // Mascara do buffer de recepção 2K :
#define NET_MEMORIA      0x05     // Use 8K de Tx/Rx Buffer(pode se usar até 8K)
#define MAX_BUF          100      // tamanho maximo do buffer de recepção(pode ser alterado)
/////////
//////// variaveis globais ////////////////////////////////////////
////////
char buf[MAX_BUF];//buffer para guardar os dados recebido
uint8_t ip_placa[4];
uint8_t gateway[4];
//////////////valores padrao

uint8_t sockstat=0;
char comando;
int rsize;
int tempo=0;
int enviar = 0;

//tipo de acionamento se : não acionado = 0 analogico = 1 ;botão manual = 2 ; agendamento = 3


///////////////////////função de escrita SPI////////////////////////
void ip_to_char(int quant,char convert_char[5])
{
       convert_char[0]='0';
       convert_char[1]='0';
       convert_char[2]='0';
       convert_char[3]='\0';
      while(quant>=100)
        {
         quant=quant-100;
         convert_char[0]++;
         }
       while(quant>=10)
        {
         quant=quant-10;
        convert_char[1]++;
         }
       while(quant>=1)
        {
           quant=quant-1;
         convert_char[2]++;
         }
      
}

void spi_escreve(unsigned int endereco,unsigned char dados)
{
  // ativa pino de habilitação do SPI
  SPI_PORT &= ~(1<<SPI_SS);  
  SPDR = WIZNET_ESCREVE_OPCODE;//inicializa escrita pelo W5100  
  // espera terminar a comunicação
  while(!(SPSR & (1<<SPIF))); 
   // inicialização do Wiznet W5100 envia os bytes mais significativo
  SPDR = (endereco & 0xFF00) >> 8;
   // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF))); 
   //inicialização do Wiznet W5100 envia os bytes menos significativo
  SPDR = endereco & 0x00FF;  
  // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF)));   

  SPDR = dados;  // inicializa transmissão de dados
  while(!(SPSR & (1<<SPIF))); // espera finalizar a transmissão
  // finaliza comunicação.
  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);
  //inicializa leitura pelo W5100 
  SPDR = WIZNET_LER_OPCODE;
   // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF)));
   // inicialização do Wiznet W5100 envia os bytes mais significativo
  SPDR = (endereco & 0xFF00) >> 8;
   // espera finalizar a transmissão
  while(!(SPSR & (1<<SPIF)));
  //inicialização do Wiznet W5100 envia os bytes menos significativo
  SPDR = endereco & 0x00FF;
   // 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 W5100
}
////////////////////////inicializa ethernet //////////////////////////////////
void W5100_Inicializa(void)
{
// tanto o ip quanto o gatway pode ser alterado para sua aplicação aqui é só um exemplo.

 unsigned char porta[] = {0x13,0X88};// ex 5000 = 0X1388 -> 0X13 +0X88 //porta 5000
  //unsigned char porta[] = {0x00,0X50};// ex 80 = 0X0050 -> 0X00 +0X50 //porta tcp
  // esse mac é do AA0000 dezembro obsoleto
  unsigned char mac_addr[] = {0xAA,0x00,0x00,0xFF,0xFF,ip_placa[0]};//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[] = {ip_placa[3],ip_placa[2],ip_placa[1],ip_placa[0]};//enderreç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[] = {gateway[3],gateway[2],gateway[1],gateway[0]};//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

  spi_escreve(MR,0x80);            // MR = 0b10000000; isso inicicializa os registradores internos automaticamente
  _delay_ms(1);
  //configura porta de comunicação para acesso remoto
  spi_escreve(S0_PORT , porta[0]);
  spi_escreve(S0_PORT + 1,porta[1]);//porta de envio e de destino são iguais 
  spi_escreve(S0_DPORT , porta[0]);
  spi_escreve(S0_DPORT + 1,porta[1]);
  spi_escreve(S0_MR,MR_TCP);    // configura o registrador de modo (MR)
  _delay_ms(1);
  // configura o MAC de acesso remoto
  spi_escreve(S0_DHAR , mac_addr[0]);
  spi_escreve(S0_DHAR + 1,mac_addr[1]);
  spi_escreve(S0_DHAR + 2,mac_addr[2]);
  spi_escreve(S0_DHAR + 3,mac_addr[3]);
  spi_escreve(S0_DHAR + 4,mac_addr[4]);
  spi_escreve(S0_DHAR + 5,mac_addr[5]);
  _delay_ms(1);
  // endereço de IP de acesso remoto será sempre 1 a mais
  spi_escreve(S0_DIPR,ip_addr[0]);
  spi_escreve(S0_DIPR + 1,ip_addr[1]);
  spi_escreve(S0_DIPR + 2,ip_addr[2]);
  spi_escreve(S0_DIPR + 3,1);//ip 1  //ip_placa + 1);
  _delay_ms(1);
  //configura gateway
  spi_escreve(GAR + 0,gtw_addr[0]);///o gateway deve ter mesma faixa de ip senão não funciona,mas nunca usar ip 1 pois é do gateway.
  spi_escreve(GAR + 1,gtw_addr[1]);
  spi_escreve(GAR + 2,gtw_addr[2]);
  spi_escreve(GAR + 3,gtw_addr[3]);
  _delay_ms(1);
  // configura o MAC (SAR): 0x0009 à 0x000E
  spi_escreve(SAR ,mac_addr[0]);
  spi_escreve(SAR + 1,mac_addr[1]);
  spi_escreve(SAR + 2,mac_addr[2]);
  spi_escreve(SAR + 3,mac_addr[3]);
  spi_escreve(SAR + 4,mac_addr[4]);
  spi_escreve(SAR + 5,mac_addr[5]);
  _delay_ms(1);
  // mascara de sub rede (SUBR): 0x0005 à 0x0008
  spi_escreve(SUBR ,sub_mask[0]);
  spi_escreve(SUBR + 1,sub_mask[1]);
  spi_escreve(SUBR + 2,sub_mask[2]);
  spi_escreve(SUBR + 3,sub_mask[3]);
  _delay_ms(1);
  // endereço de IP (SIPR): 0x000F à 0x0012
  spi_escreve(SIPR,ip_addr[0]);
  spi_escreve(SIPR + 1,ip_addr[1]);
  spi_escreve(SIPR + 2,ip_addr[2]);
  spi_escreve(SIPR + 3,ip_addr[3]);
  _delay_ms(1);
  // configura o tamanho do buffer  de memoria de escrita e leitura 
  spi_escreve(RMSR,NET_MEMORIA);//configura para cada socket 2K de memoria de leitura(no W5100 tem 4 socket mas vamos usar somente o socket 0)
  spi_escreve(TMSR,NET_MEMORIA);//configura para cada socket 2K de memoria de transmissao(no W5100 tem 4 socket mas vamos usar somente o socket 0)
}
//////////////////////////////////fecha socket 0  ///////////////////////
void fechar_socket(uint8_t socket)
{
   if (socket != 0)return;
   // manda fechar
   spi_escreve(S0_CR,CR_CLOSE);   // 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
   spi_escreve(S0_CR,CR_DISCON);   // 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
    spi_escreve(S0_CR,CR_OPEN);                   // 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) 
     { 
         spi_escreve(S0_CR,CR_LISTEN);//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(char pacote[],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_ms(1);
         tx_tamanho= spi_ler(SO_TX_FSR);
         tx_tamanho=(((tx_tamanho & 0x00FF) << 8 ) + spi_ler(SO_TX_FSR + 1));     // Timeout para aproximadamente 100ms
         if (timeout++ > 100) 
           {
            // desconecta socket 0 pois não há espaço livre após 1S
           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) 
    {
      buffer_tamanho--;
      // calcula o endereço real do buffer de transmissão. 
      ende_real = TXBUFADDR + (ende_temp & TX_BUF_MASK);      // copia pacote para W5100(TX_buffer)
      spi_escreve(ende_real,pacote[tx_tamanho]);
      ende_temp++;
      tx_tamanho++;
    }
    // incrementa valor de  S0_TX_WR , então este será o ponto da proxima transmissão
    spi_escreve(S0_TX_WR,( ende_temp & 0xFF00) >> 8 );
    spi_escreve(S0_TX_WR + 1,( ende_temp & 0x00FF));
    // agora envia o comando de enviar dados para rede.
    spi_escreve(S0_CR,CR_SEND);
    // espera terminar o envio
    while(spi_ler(S0_CR));
    return 1;
}

/////////////////////////////////recebe pacote//////////////////////////////////////////
int  recebe_pacote(char pacote[],int taman)
{
        unsigned int ponteiro,ende_temp,ende_real; 
        char recebido;
        int posicao=0;
        int flag_local=0;
        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(taman) 
        {
          taman--;
          ende_real=RXBUFADDR + (ende_temp & RX_BUF_MASK);//endereço inicial de leitura + endereço dos dados recebidos 
          recebido = spi_ler(ende_real);
          if((flag_local ==1)&&(recebido == '>'))
            {
             flag_local=2;
             taman = 0;
             pacote[posicao] = '>';// String de fim de pacote
             pacote[posicao+1] = '\0';// String de fim de pacote
             }
          if(flag_local ==1)
             {
               if(posicao == 0)
               {
                 comando = recebido;
               }
               else
               {
                pacote[posicao-1] = recebido;
                }
               posicao++;
              }
          if(recebido == '<')
          {
            posicao = 0;
            flag_local=1; 
          } 
          ende_temp++;
          
        }
    // incrementa S0_RX_RD ,este será o ponto da proxima recepção
    spi_escreve(S0_RX_RD,(ende_temp & 0xFF00) >> 8 );
    spi_escreve(S0_RX_RD + 1,(ende_temp & 0x00FF));///////////////////////////////////////////////////vou ver isso//////////
    //envia comando para leitura 
    spi_escreve(S0_CR,CR_RECV);
    _delay_us(5);    // espera terminar leitura.
    rsize=posicao;//atualiza o novo valor de rsize
    return(flag_local);                
}
///////////////////////////////////////////////////////////////////////
int Buffer_recepcao(void)
{
  return (((spi_ler(S0_RX_RSR) & 0x00FF) << 8 ) + spi_ler(S0_RX_RSR + 1)); //
}
////////////////////////////////////////////////////////////////////////
int procura_string(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;
}
////////////////////////funçoes auxiliares///////////////////////////////

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 principal/////////////////////////////////////
int main(void)
 {
  
  //////////////////inicializa port D e port C /////////////////////////////////////////////////////////////////////
  DDRD = 0x0F;//configura port D 
  PORTD = 0x00;//desabilita pull ups
  DDRC = 0x00;//configura port C como entradas
  PORTC = 0XFF; //se estiver como saida liga as saidas e se estiver como entrada habilita pull ups
  //i = PINB; //ler pinos
//  MUX = 0X40; //usar PORTC0, justificado a direita,referencia ligada ao VCC " colocar cap no AREF "
  //DIDR0 = 0X00;////desabilita entrada analogico(reduz consumo).evita problemas quando esse pino é usado como saida
  DDRB = 0x2F;//configura port B
  PORTB = 0x00;
  inicializa_spi();    //comunicação spi

    /* if(estado_pino(PIND,PD4))//reseta ip
                     {//sim(pressionado em nivel baixo)
                      _EEPUT(28,'I');//endereço/dado1  //indica que ip deve se alterado para padrão
                     }
                     */
////////////aqui configuro o ip e gatway //////////////
             ip_placa[3]=192;
             ip_placa[2]=168;
             ip_placa[1]=0;
             ip_placa[0]=5;

             gateway[3]=ip_placa[3];
             gateway[2]=ip_placa[2];
             gateway[1]=ip_placa[1];
             gateway[0]=1;

  enviar = 0;
  desliga_pino(PORTB,PB1);///// //reseta o chip de ethernet
  _delay_ms(10);//isso garante uma inicialização do modulo de forma correta
  liga_pino(PORTB,PB1);
  W5100_Inicializa();  //inicializa modulo ethernet
  desliga_pino(PORTD,PD1);//apaga led de comando 
  ///////////////////////////////////
  sei();//habilita interrupções
  ///////////////////////////////////////////////////////
 //OBS : devo desabilitar o bit RSTDISBL para qu e o pino C6 possa ser usado como I/O
 ///////////////////////////////////////////////////////
  for(;;)
    {
         
        if(tempo> 5000)//tempo qualquer 
          {
            alterna_pino(PORTD,PD0);//faz um led piscar
            tempo =0;
          }
          tempo++;                                   
     ////////////////////////rotina ethernet////////////////////////
            sockstat=spi_ler(S0_SR);
            switch(sockstat) 
            {
             case SOCK_CLOSED: ///socket fechado. fica escutando a rede
                 { 
                            if (conex_servidor(0) > 0) //como o socket está fechado,ele fica no modo servidor  escutando a rede
                             {// 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
                  if (Buffer_recepcao() > 0)//checa buffer de recepção
                     {
                      // lê o pacote recebido e verifica se é valido
                          rsize=((spi_ler(S0_RX_RSR) & 0x00FF) << 8 ) + spi_ler(S0_RX_RSR + 1);//pega tamanho dos dados recebido
                          if(recebe_pacote(buf,rsize) == 2)//indica que está ok
                          {
                              int flag_erro = 0;
                              _delay_ms(500);//tempo de resposta pode ser aterado                         
                               if (comando == 'L') //comando para pegar o status do modulo
                                 {
                                     flag_erro = 1;
                                     liga_pino(PORTD,PD1);//apaga led de comando
                                     char frase[6]; // indica que ligou
                                         frase[0]='L';
                                         frase[1]='i';
                                         frase[2]='g';
                                         frase[3]='o';
                                         frase[4]='u';
                                         frase[5]='\0';
                                     
                                     if (envia_pacote(frase,6) <= 0)//envia pacote
                                     break;//se falhar sai da conexão
                                 }//fim do Status
                                 //strlen(buf)
                                  if (comando == 'D') //modo teste
                                 {
                                     flag_erro = 1;
                                     desliga_pino(PORTD,PD1);//apaga led de comando
                                     char frase[6]; // indica que desligou
                                         frase[0]='D';
                                         frase[1]='e';
                                         frase[2]='s';
                                         frase[3]='l';
                                         frase[4]='.';
                                         frase[5]='\0';
                                     
                                     if (envia_pacote(frase,6) <= 0)//envia pacote
                                     break;//se falhar sai da conexão
                                 }//fim do Status                              
                            
                               if (flag_erro == 0)
                                     {
                                         char dados_locais[5];
                                         dados_locais[0]='E';
                                         dados_locais[1]='R';
                                         dados_locais[2]='R';
                                         dados_locais[3]='O';
                                         dados_locais[4]='\0';
                                         if (envia_pacote(dados_locais,5) <= 0)
                                         break;//se falhar sai da conexão
                                     }//fim do erro
                            }//fim leitura do pacote
                  //   desconectar(0);// desconecta socket 0
                    }//pacote maior que zero          
              }break;//fim socket estabilizado      
              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

      ////////////////////////fim da rotina ethernet////////////////////////

   }//chave do laço infinito (for)
}//chave de main//

agora é só configurar no avr studio o oscilador para 16MHZ(pode ser alterado) e otimizações  para 01,conforme figura:

se for programar usando o Burn-o-mat deixei os fuses assim:


depois de tudo pronto e chip gravado é hora de testar(lembre que aqui alterei o pino de reset do modulo para B1, no artigo anterior era B0),o led que piscar(indicando quando está conectado(pisca de velocidade diferentes)) deve está no pino D0 e o led que será controlado no pino D1,para fazer acender o led envie <L> para a placa e para desligar <D>. eu usei um programa que eu fiz no visual Studio há um tempo atrás veja a figura:

depois disto fiz um outro em java para testar, quem tiver se interessado em fazer este projeto basta me enviar um e-mail que eu mando estes softwares gratuitamente . 


Um comentário :

  1. Há possibilidade de fornecer o esquema elétrico deste projeto?

    Obrigado

    ResponderExcluir

olá,digite aqui seu comentário!