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 .