Servidor Web con PIC18F4550 y ENC28j60

En este proyecto se va a tratar un ejemplo básico de conexión de un PIC 18F4550 a una red ethernet por mediación del enc28j60. El control del PIC se realiza accediendo mediante una dirección IP que mostrará una página web, alojada en la propia memoria del PIC, y accesible con el explorador de internet desde cualquier dispositivo conectado a dicha red.

La web nos mostrará una página principal (\index). Desde ella podremos activar 3 salidas del PIC mediante sendos botones. También podremos enviar textos que veremos representados en un display lcd. Una página secundaria, accesible desde la principal, nos monitorizará las lecturas realizadas por el PIC (el canal analógico AN0 y el estado del bit 0 del puerto E).

Se va a mostrar el ejemplo simulándolo bajo proteus. Para ello, será necesario instalar WinPcap.

A la hora de crear el programa del PIC lo primero es especificar los criterios de configuración elegidos que se van a tener en cuenta a la hora de cargar el stack tcpip y que van a determinar que opciones van a ser utilizadas.

#define STACK_USE_ICMP       1  //Módulo de respuesta ICMP (ping)

#define STACK_USE_ARP        1  //Para solucionar direccionamiento MAC de las IP

#define STACK_USE_TCP        1  //Para enviar paquetes TCP 

#define STACK_USE_HTTP       1  //Uso de las funciones http del stack.

#define STACK_USE_CCS_PICENS 1  //CCS PICENS 18F4620 + ENC28J60

#define STACK_USE_MCPENC     1  //Uso del enc28j60 por el stack (stacktsk.c)

#define STACK_USE_MAC        1  //Uso de la tarjeta de red

También hay que incluir el número de puerto, necesario cuando accedamos a través de internet.

#define   HTTP_SOCKET 80        //Nº de puerto asociado al socket. 

El PIC se comunica con el enc28j60 mediante el bus SPI. Para definir los pines del PIC que van a ser utilizados para este propósito existen 3 posibilidades:

Opción 1.

No definir nada, en cuyo caso se implementará una comunicación SPI por software y se tomará la definición de patillas establecida dentro del archivo enc28j60.c

#define PIN_ENC_MAC_SO  PIN_D7  

#define PIN_ENC_MAC_SI  PIN_D6  

#define PIN_ENC_MAC_CLK PIN_D5

#define PIN_ENC_MAC_CS  PIN_D4

#define PIN_ENC_MAC_RST PIN_D3

#define PIN_ENC_MAC_INT PIN_D2

#define PIN_ENC_MAC_WOL PIN_D1

Opción 2.

Definir todas las patillas para la comunicación SPI, con lo que se implementará una comunicación SPI por software con la definición de patillas elegida. La definición existente dentro del archivo enc28j60.c será en este caso ignorada. Por ejemplo...

#define PIN_ENC_MAC_SO  PIN_C4

#define PIN_ENC_MAC_SI  PIN_C5  

#define PIN_ENC_MAC_CLK PIN_B4  

#define PIN_ENC_MAC_CS  PIN_B5  

#define PIN_ENC_MAC_RST PIN_B6

#define PIN_ENC_MAC_INT PIN_B7   

Opción 3.

Habilitar el uso de SPI por hardware del PIC y definir las patillas ajenas al hardware del módulo SPI (CS, INT y RST). En este caso es imprescindible definir también la patilla SO para que el stack (dentro del archivo enc28j60.c) no habilite el SPI por software. Da igual que patilla SO se defina, la que se deberá cablear será la SO real, así como SI y CLK.

#define ENC_MAC_USE_SPI 1          //Uso del SPI por hardware

#define PIN_ENC_MAC_SO  PIN_B0     //Entrada serie de datos

//#define PIN_ENC_MAC_SI  PIN_C7   //Salida serie de datos(no necesario definir)

//#define PIN_ENC_MAC_CLK PIN_B1   //Señal de reloj  (no necesario definir)

#define PIN_ENC_MAC_CS  PIN_B2     //Chip select

#define PIN_ENC_MAC_RST PIN_B3     //Reset

#define PIN_ENC_MAC_INT PIN_B4     //Interrupción

Una observación. Aunque estamos definiendo también las patillas RST e INT, en este ejemplo, no van a ser cableadas.

Con todas las opciones definidas se puede cargar el stack tcpip.

#include "tcpip/stacktsk.c"      //Carga el stack TCP/IP de Microchip 

La dirección MAC identificará el dispositivo hardware dentro de la red. No puede haber, por tanto, dos dispositivos con la misma dirección MAC conectados a una misma red. 

   MY_MAC_BYTE1=0;

   MY_MAC_BYTE2=2;

   MY_MAC_BYTE3=3;

   MY_MAC_BYTE4=4;

   MY_MAC_BYTE5=5;

   MY_MAC_BYTE6=6;

Esta asignación se ha definido dentro de la función MACAddrInit() a la que accederemos desde la función principal main(), antes de ejecutar las tareas del stack tcpip.

Lo mismo para la función IPAddrInit(). Dentro de la cual se ha especificado cual va a ser la dirección IP de nuestro servidor web, la dirección IP de la puerta de enlace y la máscara de subred. 

   //Elección de la dirección IP. 

   MY_IP_BYTE1=192;

   MY_IP_BYTE2=168;

   MY_IP_BYTE3=1;

   MY_IP_BYTE4=15;

   //Elección de la dirección de puerta de enlace.

   MY_GATE_BYTE1=192;

   MY_GATE_BYTE2=168;

   MY_GATE_BYTE3=1;

   MY_GATE_BYTE4=1;

   //Elección de la máscara de subred. 

   MY_MASK_BYTE1=255;

   MY_MASK_BYTE2=255;

   MY_MASK_BYTE3=255;

   MY_MASK_BYTE4=0;

Antes ejecutar las tareas del stack tcpip hay que inicializarlo:

   StackInit();   //Inicializa el stack

Y posteriormente mantenerlo funcionando mediante un bucle infinito:

   while(TRUE) {

       StackTask();

   }

Con el stack funcionando, cuando apliquemos la ip del servidor web en la barra de direcciones del explorador de internet de otro dispositivo conectado a la misma red, deberá aparecer la página que se encuentra contenida dentro del código del pic. De ello se encarga la función:

int32 http_get_page(char *file_str){}

Definida por el stack, localiza la posición de memoria dentro del PIC donde se encuentra el código correspondiente a la página solicitada. Previamente habremos diseñado la página web con código html y lo habremos introducido dentro del código del PIC como una constante. Tanto la página principal:

const char HTML_INDEX_PAGE[]="  "

Como la página secundaria:

const char HTML_LECTURAS_PAGE[]="  "

Con la página cargada, la aplicación web ya puede interactuar con la aplicación del PIC. Aunque en realidad, recordemos que ambas conviven como parte del código en el propio PIC. Para ello se emplean otras dos funciones igualmente definidas por el stack. 

La función:

void http_exec_cgi(int32 file, char *key, char *val) {}

Recibe los cambios producidos en la aplicación web y los refleja en el código del PIC. Dentro de ella, programaremos  las actuaciones que deben ejecutarse  en función de los cambios producidos en la página web. En nuestro caso, activar 3 salidas o recibir un texto para mostrar sobre el lcd.

Por ejemplo, la parte del código html que crea uno de los botones es:

<FORM METHOD=GET>

<input type=\"submit\" name=\"boton1\" value=\"Botón 1\">

</FORM>

Cuando en la aplicación web se pulsa dicho botón, se envía la información "boton1" por mediación de la variable key. En el código del PIC se detecta el cambio cuando dentro de la función se compara dicha información con ciertas variables preestablecidas. Si la información es coincidente con alguna de ellas, se ejecutará la actuación correspondiente.

   static char boton1_key[]="boton1";

   static char boton2_key[]="boton2";

   static char boton3_key[]="boton3";

   if (stricmp(key,boton1_key)==0) {

      output_toggle(PIN_C0);

   }

La otra función:

int8 http_format_char(int32 file, char id, char *str, int8 max_ret) {}

Informa a la aplicación web del estado de las variables medidas por el PIC. Dicha función ofrece los valores que han de representarse en la página web cuando ésta se carga. Por ejemplo, la parte del código referente a la representación del valor de la lectura del canal analógico:

<P><B>AN: </B>%0 </P>

Mostrará, por mediación de la función anterior, el valor de la variable virtual %0 que corresponderá con la lectura física del canal analógico del PIC.

 case '0':

     set_adc_channel(0);

     delay_us(100);

     AD0=read_adc();

     sprintf(new_str,"0x%X",AD0);

     len=strlen(new_str);

 break;

[+/-] Ver / Ocultar código C PIC (Código principal)

////////////////////////////////////////////////////////////////////////////////

//                                                                            //

//                SERVIDOR WEB CON PIC 18F4550 Y ENC28J60                     //

//                                                                            //

//                      ccs PIC C compiler v4.104                             //

//                                                                            //

//                         (c) RobotyPic 2015                                 //

//                                                                            //

////////////////////////////////////////////////////////////////////////////////

// Conmuta encendido-apagado de 3 leds controlados desde la aplicación web    //

// Muestra variables leídas por el PIC: Canal analógico An0 y estado bit RE0  //

// Representa en lcd el texto introducido desde la aplicación web             //

////////////////////////////////////////////////////////////////////////////////

#include <18F4550.h>

#device ADC=8

#use delay(clock=20000000)

#fuses HS,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,VREGEN,NOPBADEN,WRTB

#byte porte = 0xF84

/** Configuración para el uso del stack tcip **/

#define STACK_USE_ICMP        1  //Módulo de respuesta ICMP (ping)

#define STACK_USE_ARP         1  //Para solucionar direccionamiento MAC de las IP

#define STACK_USE_TCP         1  //Para enviar paquetes TCP 

#define STACK_USE_HTTP        1  //Uso de las funciones http del stack.

#define STACK_USE_CCS_PICENS  1  //CCS PICENS (Embedded Ethernet) 18F4620 + ENC28J60

#define STACK_USE_MCPENC      1  //Uso del enc28j60 por el stack (stacktsk.c)

#define STACK_USE_MAC         1  //Uso de la tarjeta de red

#define HTTP_SOCKET 80           //Nº de puerto asociado al socket.

/********** Definición del patillaje de conexión al enc28j60 ******************/

/* Existen varias posibilidades:

Opción 1. No definir nada, en cuyo caso se implementará una comunicación SPI por 

software y se tomarán la definición de patillas establecida en enc28j60.c

SO  PIN_D7 ---- ENC >>>> PIC

SI  PIN_D6 ---- PIC >>>> ENC

CLK PIN_D5

CS  PIN_D4

RST PIN_D3

INT PIN_D2

WOL PIN_D1

Opción 2. Definir todas las patillas de la comunicación SPI, en cuyo caso se 

implementará una comunicación SPI por software con la definición de patillas 

elegida. Por ejemplo...

#define PIN_ENC_MAC_SO  PIN_C4   //Entrada serie de datos

#define PIN_ENC_MAC_SI  PIN_C5   //Salida serie de datos

#define PIN_ENC_MAC_CLK PIN_B4   //Señal de reloj

#define PIN_ENC_MAC_CS  PIN_B5   //Chip select

#define PIN_ENC_MAC_RST PIN_B6   //Reset

#define PIN_ENC_MAC_INT PIN_B7   //Interrupción

Opción 3. El que aquí se ha utilizado, que consiste en habilitar el uso de SPI 

por hardware del PIC y definir las patillas ajenas al hardware del módulo SPI 

(CS, INT y RST). En este caso es imprescindible definir también la patilla SO 

para que el stack (dentro de enc28j60.c) no habilite SPI por software. Da igual 

que patilla SO se defina, la que se deberá cablear será la SO real del PIC    */

#define ENC_MAC_USE_SPI 1           //Uso del SPI por hardware

#define PIN_ENC_MAC_SO  PIN_B0      //Entrada serie de datos

//#define PIN_ENC_MAC_SI  PIN_C7    //Salida serie de datos (no necesario definir)

//#define PIN_ENC_MAC_CLK PIN_B1    //Señal de reloj  (no necesario definir)

#define PIN_ENC_MAC_CS  PIN_B2      //Chip select

#define PIN_ENC_MAC_RST PIN_B3      //Reset

#define PIN_ENC_MAC_INT PIN_B4      //Interrupción

/******************************************************************************/

#define use_portd_lcd TRUE       //Uso del puerto d para control del lcd

#include <LCD420PIC18F_RyP.c>    //Carga librería del lcd de 4x20 para familia 18F

#include "tcpip/stacktsk.c"      //Carga el stack TCP/IP de Microchip 

/*********************  PAGINA WEB A MOSTRAR **********************************/

/* Página principal INDEX (/) */

const char  HTML_INDEX_PAGE[]="

<HTML><BODY BGCOLOR=#FFFFFF TEXT=#000000>

<IMG SRC=\"http://www.robotypic.com/ryp.png\"><P>

<center><H1>Servidor WEB con PIC 18f4550 </H1></center>

<BR><center><H2>ROBOTYPIC</H2></CENTER>

<FORM METHOD=GET>

<P>LCD: <INPUT TYPE=\"text\" NAME=\"lcd\" size=20 maxlength=16>

<input type=\"submit\" value=\"Enviar texto\">

</FORM>

<FORM METHOD=GET>

<input type=\"submit\" name=\"boton1\" value=\"Botón 1\">

</FORM>

<FORM METHOD=GET>

<input type=\"submit\" name=\"boton2\" value=\"Botón 2\">

</FORM>

<FORM METHOD=GET>

<input type=\"submit\" name=\"boton3\" value=\"Botón 3\">

</FORM>

<P><A HREF=\"/lecturas\">Lecturas del PIC</A>

</BODY></HTML>

";

/* Página secundaria (\lecturas). Accesible desde la página principal */

const char  HTML_LECTURAS_PAGE[]="

<meta http-equiv=\"refresh\"content=\"3;url=lecturas\">

<HTML><BODY BGCOLOR=#FFFFFF TEXT=#000000>

<IMG SRC=\"http://www.robotypic.com/ryp.png\"><P>

<center><H1>Servidor WEB con PIC 18f4550 </H1></center>

<BR><center><H2>ROBOTYPIC</H2></CENTER>

<br><center>LECTURAS</center>

<P><B>AN: </B>%0 </P>

<BR/>

<P><B>RE0: </B>%1 </P>

<BR/>

<P><A HREF=\"/\">LCD/LEDs</A>

</BODY></HTML>

";

/* Elección de MAC. No puede haber 2 dispositivos con misma MAC en una misma red

   Microchip Vendor ID  MAC: 00.04.A3.xx.xx.xx.  */

void MACAddrInit(void) {

   MY_MAC_BYTE1=0;

   MY_MAC_BYTE2=0x04;

   MY_MAC_BYTE3=0xA3;

   MY_MAC_BYTE4=0x06;

   MY_MAC_BYTE5=0x07;

   MY_MAC_BYTE6=0x08;

}

void IPAddrInit(void) {

   //Elección de la dirección IP. 

   MY_IP_BYTE1=192;

   MY_IP_BYTE2=168;

   MY_IP_BYTE3=1;

   MY_IP_BYTE4=15;

   //Elección de la dirección de puerta de enlace. 

   MY_GATE_BYTE1=192;

   MY_GATE_BYTE2=168;

   MY_GATE_BYTE3=1;

   MY_GATE_BYTE4=1;

   //Elección de la máscara de red.Si no se indica nada se tomará 255.255.255.0

   MY_MASK_BYTE1=255;

   MY_MASK_BYTE2=255;

   MY_MASK_BYTE3=255;

   MY_MASK_BYTE4=0;

}

/***************************  FUNCIÓN GET PAGE   ******************************/

/* Esta función devuelve la posición de memoria donde se encuentra la página web 

a mostrar. En este caso se trata de una web con 2 páginas. Una principal index(/) 

y una secundaria(/lecturas)                                                   */

int32 http_get_page(char *file_str) {

   int32 file_loc=0;

   static char index[]="/";

   static char lecturas[]="/lecturas";

   

   printf(lcd_putc,"\fRequest %s ",file_str);      //Muestra en lcd solicitud

   /* Busca la posición de memoria donde se encuentra la página solicitada */

   if (stricmp(file_str,index)==0)                 //Si es la principal...

      file_loc=label_address(HTML_INDEX_PAGE);     //...toma su posición en la memoria

   else if (stricmp(file_str,lecturas)==0)            //O si es la secundaria...

      file_loc=label_address(HTML_LECTURAS_PAGE);    //...toma su posición en la memoria

   /* Muestra en lcd la página solicitada */

   if (file_loc){                                  //Si existe... 

      printf(lcd_putc,"\n(FILE=%LU)",file_loc);    //...muestra en lcd pos. de memoria

   }

   else{                                           //Si no existe...

      printf(lcd_putc,"\n(File Not Found)");       //...muestra en lcd mensaje

   }

  /* Devuelve la posición en la memoria donde se encuentra la página a mostrar */

   return(file_loc);                               

}

/**************************  FUNCIÓN FORMAT CHAR  *****************************/

/* Con  la función http_format_char  interconectamos las variables virtuales de 

la página web con las variables del programa del PIC. Se encarga de enviar los 

cambios producidos en la aplicación del PIC y reflejarlos en la aplicación web. 

Muestra,por tanto, las lectura obtenidas por el PIC y las representa en la 

aplicación de la página web      

%0 es la variable virtual para representar el valor de la lectura del canal 

analógico

%1 es la variable virtual para representar el valor de la lectura del bit 0 del 

puerto E.

*/

int8 http_format_char(int32 file, char id, char *str, int8 max_ret) {

   char new_str[20];

   int8 len=0;

   int8 AD0;

   int8 RE0;

   *str=0;

   switch(id) {

      case '0':

         set_adc_channel(0);

         delay_us(100);

         AD0=read_adc();

         sprintf(new_str,"0x%X",AD0);

         len=strlen(new_str);

      break;

      case '1':

         RE0=bit_test(porte,0);

         sprintf(new_str,"%d",RE0);

         len=strlen(new_str);

      break;  

      default:

      len=0;

   }

   if (len)strncpy(str, new_str, max_ret);

   else  *str=0;

   

   return(len);

}

/***************************  FUNCIÓN EXEC CGI   ******************************/

/* Con la función http_exec_cgi interconectamos las variables virtuales de la 

página web con las variables del programa del PIC. Se encarga de recibir 

los cambios producidos en la aplicación web y reflejarlos en el hardware del PIC. 

Ejecuta, por tanto, la acción elegida según el valor de la variable virtual recibida 

de la página web

key es la variable virtual que viene de la pagina web

val es el valor de una variable virtual de la página web

file es la dirección de la página web devuelta por http_get_page ()

*/

void http_exec_cgi(int32 file, char *key, char *val) {

   static char boton1_key[]="boton1";

   static char boton2_key[]="boton2";

   static char boton3_key[]="boton3";

   static char lcd_key[]="lcd";

   printf(lcd_putc,"\fCGI FILE=%LD", file);

   printf(lcd_putc,"\nKEY=%S", key);

   printf(lcd_putc,"\nVAL=%S", val);

   /* Se ejecutará al pulsar el botón "Botón 1" en la aplicación web */

   if (stricmp(key,boton1_key)==0) {

      output_toggle(PIN_C0);

   }

   /* Se ejecutará al pulsar el botón "Botón 2" en la aplicación web */

   if (stricmp(key,boton2_key)==0) {

      output_toggle(PIN_C1);

   }

   /* Se ejecutará al pulsar el botón "Botón 3" en la aplicación web */

   if (stricmp(key,boton3_key)==0) {

      output_toggle(PIN_C2);

   }

   /* Se ejecutará al pulsar el botón "Enviar texto" en la aplicación web */

   if (stricmp(key,lcd_key)==0) {

      printf(lcd_putc,"\f%s",val);  //Muestra en el lcd el texto recibido

   }

}

/************************** FUNCIÓN PRINCIPAL *********************************/

void main(void) {

   /* Habilitación y configuración del canal analógico 0 */

   setup_adc(ADC_CLOCK_INTERNAL);

   setup_adc_ports(AN0);

   set_adc_channel(0);

   delay_ms(1);

   

   /*Reset de las salidas */

   output_low(PIN_C0);

   output_low(PIN_C1);

   output_low(PIN_C2);

    

   /* Inicialización del lcd */

   lcd_init();

   printf(lcd_putc,"\fROBOTYPIC WEB SERVER");   //Mensaje de inicio en lcd 

   delay_ms(1000);

  

   /* Inicialización del Stack */

   MACAddrInit(); //Se asigna la dirección MAC elegida 

   IPAddrInit();  //Se asigna IP, mascara de red y puerta de enlace elegidos

   StackInit();   //Inicializa el stack

   

   /* Muestra la IP elegida en lcd */

   printf(lcd_putc,"\n\n IP: %u.%u.%u.%u", MY_IP_BYTE1, MY_IP_BYTE2, MY_IP_BYTE3, MY_IP_BYTE4);

   printf(lcd_putc,"\n %u", HTTP_SOCKET);

   delay_ms(10);

   while(TRUE) {

      StackTask();

    }

}

Para hacerlo funcionar, conectamos el PIC a la red ethernet del router. Desde otro dispositivo conectado a la misma red (al router), en la barra de direcciones del explorador, tecleamos la dirección IP que hemos asignado a nuestro servidor web (162.168.1.15). Si todo va bien nos aparecerá la página que hemos cargado en el PIC y desde la que podremos interactuar.

En esta simulación se ha visto como acceder al PIC desde un dispositivo conectado a la red ethernet interna. Si lo que queremos es acceder desde el exterior por internet, en la barra de direcciones del explorador deberemos escribir la dirección IP con la que se identifica nuestro router en internet y el número de puerto (puerto 80). Por ejemplo 87.64.15.102:80 

Previamente, deberemos haber configurado el router de forma que redirija el trafico que le llega desde el exterior hasta el servidor web. En dicha configuración, tendremos que abrir el puerto 80 TCP para la dirección IP del servidor web (192.168.1.15).

Para saber la dirección IP de nuestro router en internet, podemos ayudarnos de muchas páginas que nos la pueden proporcionar. Una de ellas es http://www.cualesmiip.com/. 

Esquema completo para el montaje real:

Descarga de los archivos del proyecto:

Webserver PIC18F4550+ENC28j60

El proyecto contenido en el artículo ha sido diseñado y probado utilizando las siguientes versiones de software:

- Windows xp, windows 7 (32 bits) y windows 8 (64 bits)

- Proteus V7.7 SP2

- CCS PIC C COMPILER v4.104

Artículo relacionado>> Servidor Web PIC18f4620+enc28j60