Enc28j60 + pic18f2550 + c18

[Tiago Shimizu]

Olá pessoal, estou tendo problemas em configurar um módulo ENC28J60 em um microcontrolador 18F2550 no C18. Basicamente preciso abrir um socket de comunicação entre o pic e o pc para obter algumas informações. Utilizo um cristal de 20MHz e meu código está assim:

#include <p18f2550.h>

#define _XTAL_FREQ 20000000      // cristal de 20 Mhz
#pragma config FOSC = HS
#pragma config CPUDIV = OSC1_PLL2
#pragma config WDT = OFF
#pragma config PBADEN = OFF
#pragma config LVP = OFF
#pragma config PWRT = ON
#pragma config DEBUG= OFF
#pragma config MCLRE = OFF 
  
#pragma udata
void YourLowPriorityISRCode();
void YourHighPriorityISRCode();
#define REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS	0x08
#define REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS	    0x18

#pragma code REMAPPED_HIGH_INTERRUPT_VECTOR = REMAPPED_HIGH_INTERRUPT_VECTOR_ADDRESS
void Remapped_High_ISR (void)
{
     _asm goto YourHighPriorityISRCode _endasm
}
#pragma code REMAPPED_LOW_INTERRUPT_VECTOR = REMAPPED_LOW_INTERRUPT_VECTOR_ADDRESS
void Remapped_Low_ISR (void)
{
     _asm goto YourLowPriorityISRCode _endasm
}
#pragma code

#pragma interrupt YourHighPriorityISRCode
void YourHighPriorityISRCode()
{   
    
}	
#pragma interruptlow YourLowPriorityISRCode
void YourLowPriorityISRCode()
{
  TickUpdate();
}
  
void main(void)
{
  static TICK t = 0;
  while (1) 
  {
     TickInit();
     InitAppConfig();
     StackInit();
     while (1) 
     {
        if (TickGet() - t >= TICK_SECOND / 2ul) 
        {
           t = TickGet();
        }

        StackTask();
        StackApplications();
        #if defined(STACK_USE_TCP_SERVER)
          ServerSocketTCP();
        #endif
     }
  }
}
  
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};

void InitAppConfig(void) {
    AppConfig.Flags.bIsDHCPEnabled = TRUE;
    AppConfig.Flags.bInConfigMode = TRUE;
    memcpypgm2ram((void*) &AppConfig.MyMACAddr, (ROM void*) SerializedMACAddress, sizeof (AppConfig.MyMACAddr));
    memcpypgm2ram(AppConfig.NetBIOSName, (ROM void*) MY_DEFAULT_HOST_NAME, 16);
    FormatNetBIOSName(AppConfig.NetBIOSName);
    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;
}

void ServerSocketTCP(void) {
    WORD lenA;
    BYTE i;
    static DWORD timeout[SERVER_CONNS];
    static TCP_SOCKET MySocket[SERVER_CONNS];
    //unsigned char buf[253];
    unsigned char buf[];
    static enum _TCPServerState {
        SM_HOME = 0,
        SM_LISTENING,

    } maquina_estado_servidor = SM_HOME;

    //maquina de estado
    switch (maquina_estado_servidor) {
            //----------------------------------------------------------------------
        case SM_HOME:
            for (i = 0; i < SERVER_CONNS; i++) {
                //faz alocação de de buffer para os sockets
                MySocket[i] = TCPOpen(0, TCP_OPEN_SERVER, SERVER_PORT, TCP_PURPOSE_GENERIC_TCP_SERVER);
                timeout[i] = TickGet();
            }
            maquina_estado_servidor = SM_LISTENING;
            break;
            //----------------------------------------------------------------------
        case SM_LISTENING:
            for (i = 0; i < SERVER_CONNS; i++) {
                if (TCPIsConnected(MySocket[i])) {

                    lenA = TCPIsGetReady(MySocket[i]);

                    //se passou 15 segundos e nao recebeu nada desconecta
                    if (TickGet() - timeout[i] >= TICK_SECOND * 15) {
                        TCPDisconnect(MySocket[i]);
                    }
                } else {
                    timeout[i] = TickGet();
                }
            }
            break;
            //----------------------------------------------------------------------
    }
}

O arquivo HardwareProfile.h está assim:

#ifndef __HARDWARE_PROFILE_H
#define __HARDWARE_PROFILE_H

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

#define GetSystemClock()  (20000000ul)   // Hz
#define GetInstructionClock() (GetSystemClock()/4)
#define GetPeripheralClock()  (GetSystemClock()/4)

//ENC28J60 I/O pins
#define ENC_RST_TRIS	(TRISCbits.TRISC0)
#define ENC_RST_IO		(LATCbits.LATC0)
#define ENC_CS_TRIS		(TRISCbits.TRISC1)
#define ENC_CS_IO		(LATCbits.LATC1)
#define ENC_SCK_TRIS	(TRISBbits.TRISB1)
#define ENC_SDI_TRIS	(TRISBbits.TRISB0)
#define ENC_SDO_TRIS	(TRISCbits.TRISC7)
#define ENC_SPI_IF		(PIR1bits.SSPIF)
#define ENC_SSPBUF		(SSPBUF)
#define ENC_SPISTAT		(SSPSTAT)
#define ENC_SPISTATbits	(SSPSTATbits)
#define ENC_SPICON1		(SSPCON1)
#define ENC_SPICON1bits	(SSPCON1bits)
#define ENC_SPICON2		(SSPCON2)

Alguém poderia me ajudar?

 

Obrigado.

[Tiago Shimizu]

Pessoal, já não sei mais se estou fazendo certo agora.... ou se meus cálculos estão certos. 

Estou utilizando um cristal de 20MHz. Até onde sei, para microcontroladores da família 18F, o cálculo seria:

// Fmaq = Fosc / 4 => Fmaq = 20MHz / 4 => 5MHz
#define GetSystemClock()  (20000000ul)   // 20MHz
#define GetInstructionClock() (GetSystemClock()/4) // 5MHz
#define GetPeripheralClock()  (GetSystemClock()/4) // 5MHz

Nessas configurações, o ENC28J60 começa a querer comunicar mas logo em seguida desliga. Agora, se altero o valor de divisão do GetSystemClock() de 4 para valores bem mais altos, 40 por exemplo, ele começa a comunicar com o PC, fica uns 2 segundos, e cai a comunicação.

Estou certo em meus cálculos?