Mi primer WEB - firteconline.com.arfirteconline.com.ar/C18/web1.pdf · debe entender que para poder...

Mi primer WEB Si bien el aspecto del proyecto puede intimidar por la cantidad de archivos que contiene, (alrededor de 54 en total) la verdad es que solo nos moveremos en tres:

main.c, config.h y hardware.h. Estos tres archivos contienen toda la información necesaria para personalizar nuestro Stack y adecuarlo a casi cualquier configuración de trabajo.La idea de trabajar con este Stack es la de poder adaptarlo a sistemas de relativa simpleza y bajo costo con una transferencia real de 10Mbits.En este primer ejemplo vamos a colocar un sitio web dentro de una memoria 25LC256 con el cual vamos a controlar el estado de dos LED´s y recibir el voltaje leído desde el conversor analógico por el canal AN0.

Debe usted estar seguro que su electrónica no tiene problemas, conexiones flojas, fuente de alimentación deficiente, etc.

Intencionalmente este trabajo ha sido construido en un simple protoboard en lugar de usar alguna entrenadora adecuada, esto para poder graficar claramente la simpleza de su implementación a nivel de hardware y la posibilidad de ajustarlo a casi cualquier aplicación que requiera Ethernet.

El proyecto del web-server ya esta ajustado para ser compilado sin problemas sin embargo se debe entender que para poder compilar el proyecto desde cero debemos hacer algunos ajustes en el MPLAB.Para esto nos paramos en el árbol de proyecto, sobre el nombre del proyecto, botón derecho y nos vamos a Build Options, una vez ahí debemos ir configurando las distintas partes del del MPLAB.

La capa de red esta resuelta con un ENC28J60 que nos dará conectividad a 10Mb.Podemos ensamblar la placa nosotros mismos o podemos comprar el modulo ya armado, la experiencia dice que hay algunos componentes de esta electrónica un tanto complejos de conseguir como el cristal de 25Mhz, los transformadores adaptadores en el conector RJ45 y algunas resistencias de precisión. Debe respetar los valores detallados en el diagrama NO FUNCIONA DE OTRA FORMA!!Por esto es que recomendamos comprar la placa ya armada puesto que tiene un costo muy económico y no vale la pena encarar el armado de la misma.

Observe las imágenes en la pagina siguiente para tener una idea del hardware necesario y la estructura del proyecto como así también la configuración del MPLAB.

Taller practico Ethernet con PIC´s 1

Configurar el MPLAB C18 para el Stack Microchip

1) Incluir las rutas de los archivos 2) Configurar correctamente el compilador

3) Configurar el modelo de memoria 4) Configurar el optimizador de C18


Desde el punto de vista electrónico necesitamos tener 3,3 Voltios para alimentar el ENC28J60.Cuidado, el PIC se alimenta con 5V lo mismo que la memoria y el SN74LS125, solo el ENC28J60 se alimenta con 3,3V (En determinados momentos este chip tiene un consumo de energía relevante).

Para el reloj de nuestro PIC usaremos un cristal de 10Mhz y dos condesadores de 18pF.

En este primer trabajo la web estará contenida en una memora SPI del tipo 25LC256, mas adelante veremos como compilar la web en la propia FLASH del microcontrolador.


Memoria 25LC256. (Alimentada a 5V)

Para adecuar los niveles de tensión entre el PIC (5V) y el ENC28J60 (3,3V) necesitaremos un adaptador como el SN74LS125. (Alimentado a 5V)

En nuestro caso solo estamos conectado un buffer, el que maneja los datos y se conecta al pin 23 del controlador (SDI).

La parte de RED la resolvemos directamente con una interfaz que ya trae montado el ENC28J60.Hemos usado este enfoque solo por practicidad pero se puede armar totalmente la electrónica siguiendo el siguiente diagrama:


Placa ya terminada. (Alimentar esta placa a 3,3V)

El diagrama electrónico de este trabajo puede verlo en los archivos:

• Circuito_PIC.pdf Contiene el diagrama completo del PIC18F4620 y sus conexiones periféricas, LED´s, Memorias, etc.

• Circuito_ENC28J60.pdf Contiene el diagrama completo de la placa de RED.


La idea es lograr programar una web como la que se aprecia en la imagen dentro de la memoria 25LC256. Tome el archivo Ejemplo_1.zip y descomprimalo, el proyecto está ya listo para ser compilado, también encontrará web.b y todas las fuentes para reformar la web.

Para lograr esto necesitamos seguir varios pasos, primero la construcción de la propia pagina web que se puede realizar con cualquier herramienta web de diseño (teniendo siempre en cuenta el espacio con que contamos, no es lo mismo meter un sitio web en un servidor PC que un PIC).Nosotros para simplificar las cosas trabajaremos con una pagina ya construida la cual modificaremos con PageBreeze Luego que tenemos nuestra pagina creada debemos compilarla con la herramienta de Microchip MPFS.EXE. Esta herramienta formatea nuestra pagina web y todos los archivos vinculados a ella en un formato comprensible para el STACK y su sistema operativo.

Es decir entonces que para hacer funcionar todo necesitamos dos tipos de compilación, la del propio MPLAB que genera el archivo .hex que enviamos a la FLASH del PIC con el programador de PIC que estemos usando. Y por otro lado la compilación con MPFS del sitio web que programaremos en la memoria SPI 25LC256. Esta programación la haremos mediante el servidor FTP que esta dentro del propio STACK y al cual nos conectaremos mediante una sesión clásica FTP con cualquier soft FTP desde el lado de la computadora.Está claro entonces que para poder programar nuestro sitio dentro de la memoria 25LC256 tenemos que tener ya funcionando el STACK puesto que nos conectaremos a la memoria con el servidor FTP que esta en el propio STACK, en otras palabras, el propio micro es quien programa la memoria 25LC256 a través de una conexión remota mediante FTP tal cual lo haríamos en un servidor web informático.

Puede ver aquí un video de como funciona la carga de la web de manera remota mediante FTP.Dentro del archivo congif.h entre otras cosas usted encontrará las siguientes configuraciónes resaltadas en color rojo que son de absoluta utilidad para el control del FTP.


http://www.pagebreeze.com/

http://youtu.be/nTGDx5YWEu0

/****************************************************************************** * Global configuration file for the Microchip TCP/IP Stack * *============================================================================*#ifndef _CONFIG_H#define _CONFIG_H#include <stdio.h>#include <stdlib.h>#include <string.h>#define VERSION "1.0" // Firmware versión#include "include/Hardware.h"//*****************************************************************************// TCP/IP Config//// Define the default values for your MAC and IP configuration.// Notice that the IP addresses are separated by commas and not by the// traditional dot in the decimal dotted notation.//#define DEFAULT_MAC_ADDRESS { 0x00, 0x04, 0xa3, 0x00, 0x02, 0x00 }#define DEFAULT_IP_ADDRESS { 192, 168, 1, 201 } // IP por defecto#define DEFAULT_NETMASK { 255, 255, 255, 0 }#define DEFAULT_GATEWAY { 192, 168, 1, 1 }#define DEFAULT_NS1 { 192, 168, 1, 1 }#define DEFAULT_NETBIOS_NAME "Firtec_TCP" // Nombre por defecto

//*****************************************************************************// Stack Modules// Enable/Disable supported protocol and application modules for the TCP/IP// stack. The TCP and UDP protocol modules will be enabled according to the// modules you select here.#define STACK_USE_ICMP // ICMP reply (ping) module#define STACK_USE_HTTP_SERVER // HTTP server//#define STACK_USE_IP_GLEANING // Obtain IP address via IP Gleaning #define STACK_USE_DHCP // DHCP (Necesario si me conecto con un Router)#define STACK_USE_FTP_SERVER // FTP server activo!!!!//#define STACK_USE_TCP_EXAMPLE1 // HTTP example in tcp_client_ex1.c#define STACK_USE_ANNOUNCE // Ethernet Device Discoverer server/client//#define STACK_USE_SNTP // SNTP client #define STACK_USE_DNS // DNS client#define STACK_USE_NBNS // NetBIOS Name Service Server//#define STACK_USE_UDPTEST // Enable UDP Test code

//*****************************************************************************// Some time related definitions// Define Ticks per second for the tick manager//#define TICKS_PER_SECOND (100) // 10ms//#define USE_TIME // Include time routines#define TIME_SOURCE_TICK // Time source is Timer0 Tick counter//#define TIME_SOURCE_32KTIMER#define TZ_OFFSET (-3) // Time Zone offset (negative west of GMT)#define SNTP_UPDATE_SECS (43200) // SNTP update interval in seconds (12hrs)

//*****************************************************************************// Miscellaneous Stack Options#define ENABLE_USER_PROCESS // Esto habilita las funciones del Usuario!!!!!// Define Username and Password for the FTP Server

#define FTP_USERNAME "firtec" // Usuario para el FTP#define FTP_PASSWORD "microchip" // Pass para el FTP#define FTP_USER_NAME_LEN (10)


Observe también que hay una serie de definiciones, algunas de ellas comentadas y otras no según deseemos incluirlas en la compilación.Básicamente podemos incluir módulos, funcionalidades dependiendo si comentamos o no la inclusión de estos módulos.

Algo muy importante de recordar es que solo se puede actualizar el sitio web de manera remota siempre y cuando este esté alojado en memoria exterior, cuando el sitio está en la propia FLASH del micro será necesaria una re-programación del controlador PIC.

Como funcionan las cosas dentro del PIC.El Stack TCP/IP de Microchip es extenso y complejo como lo es el propio protocolo TCP/IP para entender como funciona vamos a tratar la interacción entre algunas funciones de configuración que están disponibles para el usuario, en definitiva gran parte del propio Stack es transparente al programador, el truco está en saber que módulos necesitamos para nuestro trabajo, y como configurar los periféricos que vamos a necesitar. Por ejemplo hay una sección dentro del main.c donde se colocan las funciones del usuario como por ejemplo control, medición, etc, en config.h está la configuración de RED, claves del FTP, dir IP, etc, en hardware.h la configuración de los pines, botónes, conversores, etc.En esencia el Stack es un pequeño sistema operativo que se ejecutado a un cierto ritmo en donde todas las funciones son ejecutadas en secuencia y a este ritmo.Dentro del main.c puede ver lo siguiente:

//////////////////////////////////////////////////////////////////////////// TAREAS DEL USUARIO SE DEFINEN EN ESTA SECCIÓN ////////////////////////////////////////////////////////////////////////#if defined(ENABLE_USER_PROCESS) ProcessIO(); // Ejecuta las tareas del usuario.// LAS TAREAS DEL SISTEMA IRIAN AQUI!!!!!!!!! //// ...........// ................// .................. #endif

Observe que se pregunta si están definidos los procesos de usuario y de ser así se ejecutan las funciones que el usuario ha escrito.Por ejemplo la función ProcessIO() contiene:

static void ProcessIO(void){float voltaje;ADCON0bits.GO = 1; while (BusyADC()==1); M0 += ReadADC(); // Lee el conversor y acumula las lecturas en M0if(4==conversiones++){ // Se tomaron 5 muestras?conversiones = 0;conversion = M0/5; voltaje=conversion; // Prepara el dato para escalarvoltaje = (voltaje*5)/1024; // Escala la medición para 10 bit´sftoa(voltaje,AN0String,2,'f'); LCDBuffer[1][4] = AN0String[0] ; // Completa el string para mostrar.LCDBuffer[1][5] = AN0String[1] ;LCDBuffer[1][6] = AN0String[2] ;LCDBuffer[1][7] = AN0String[3] ;M0=0;


LCDRefresh(); // Actualiza el LCD }}

Claramente podemos ver aquí que esta función es la encargada de leer el conversor analógico y luego de tomar 5 muestras promediarlas, escalar de acuerdo a Vref y mostrar el dato en el LCD.El sistema operativo ejecuta regularmente esta función al ritmo del propio sistema y de aquí surge una observación, podemos escribir las funciones que necesitemos pero ninguna de ellas puede acaparar la atención de la CPU porque entonces los buffer internos del ENC28J60 colapsaran y con ellos nuestro sistema de red.

El sistema operativo del Stack es del tipo cooperativo por lo tanto los tiempos son repartidos entre todas las funciones ya sean las creadas por el usurario como las del propio sistema.

Dentro del archivo hardware.h podemos ver lo siguiente:

//*****************************************************************************// Aquí se definen los pines, estado de los mismos y sentido de transferencia//// Configuración del PORTA// +-------------- n/a OSC1// |+------------- n/a OSC2// ||+------------ RA5 = LCD E (Si se usa LCD)// |||+----------- RA4 // ||||+---------- RA3 = LED2, declarado como LED1_IO// |||||+--------- RA2 = LED1, declarado como LED0_IO// ||||||+-------- RA1 = AN1// |||||||+------- RA0 = AN0#define INIT_TRISA (0b00010011)#define INIT_PORTA (0b00000000)

.

.

.

// Ajuste de los registros del Conversor#define INIT_ADCON0 (0b00000001) // ADON=0, Channel 0#define INIT_ADCON1 (0b00001101) // AN0/AN1 es analógico#define INIT_ADCON2 (0b10111110) // Configura los TAD y CK del AD. ..// Algunas macros de LEDs y botones para aplicaciones#define LED0_IO (LATAbits.LATA2)#define LED1_IO (LATAbits.LATA3)#define LED2_IO (LATEbits.LATE0)#define LED3_IO (LATDbits.LATD6)#define LED4_IO (LATDbits.LATD7)#define LED5_IO (LATDbits.LATD7) #define LED6_IO (LATDbits.LATD7) #define LED7_IO (LATDbits.LATD7) .

Todo lo referente al Hardware del usuario se define en este archivo.En este punto debemos empezar a hablar de variables reales y virtuales y saber diferenciarlas ya que si bien ambas están conectadas de manera directa existen en espacios distintos, las virtuales existen del lado de la PC y se conectan con las reales que existen del lado del microcontrolador, por ejemplo cuando actuamos sobre un botón en la web, estamos actuando sobre una variable virtual pero que se refleja en una variable real, un LED cambia de estado!!.


Entonces debe quedar entendido que las variables virtuales se conectan con variables reales y no con cualquiera sino específicamente con la variable que actúa con el hardware que nos interesa.

Todo esto puede resultar bastante confuso sobre todo si pensamos que en realidad la propia pagina que el navegador muestra sale también del microcontrolador, en definitiva nuestro navegador solo lee lo que el servidor web de nuestro PIC le envía.Podemos imagina esto como un dialogo entre capas.

1) El navegador pide la pagina.2) Se transfiere la pagina desde el PIC a la memoria del navegador (PC).3) Se oprime un botón web.4) Se decodifica el botón y se actúa sobre el hardware.

Como se decodifican los mensajes desde la web?

Dentro del Web Server hay don funciones fundamentales para la comunicación con nuestra pagina, HTTPExecCmd y HTTPGetVar, la primera es la encargada de detectar cambios en nuestra pagina y transmitir esto a nuestro micro, esta función interacciona con el hardware de acuerdo a lo que está sucediendo en la pagina web, cambiar el estado de un pin por ejemplo.Su prototipo es el siguiente:

HTTPExecCmd(BYTE** argv, BYTE argc) Donde **argv es un puntero a un arreglo bidimensional y argc es el número de parámetros enviados.

Dentro de esta función encontramos por ejemplo:

command = argv[0][0] - '0'; // Primer elemento del primer vector// Desde el archivo cgi interpreto el // comando de lo que se debe hacer.

switch(command) { case CGI_CMD_DIGOUT: var = argv[1][0] - '0'; // Primer elemento del segundo vector

// es pasado a su valor real (ascii - 0x30) switch(var) // Discrimino la acción de acuerdo al valor { case Boton_LED1: // Nombre = 0x00 LED1_IO ^= 1; // Cambio estado del LED break;

case Boton_LED2: // Nombre = 0x01 LED2_IO ^= 1; // Cambio el estado del LED break; } }}

Primero se decodifica el comando, pueden existir varios comandos dependiendo del trabajo de nuestra aplicación. Luego que se decodifica el comando se pasa a la acción de este comando, en el caso que estamos viendo el comando dice que debe cambiar el estado de un pin, Ok cual pin?Lo siguiente es decodificar el pin que se debe cambiar para encender o apagar el correspondiente LED. Observe la siguientes lineas de comando:


switch(var) <------ var es la variable virtual que llega desde la web { Boton_LED1: <----- Identificador web 0x00 (variable virtual) LED1_IO ^= 1; <----- En hardware.h >> LED1_IO (LATAbits.LATA3)

Podemos entonces decir que cuando se reciba el comando 0 desde la web el pin 5 cambiará de estado (LATAbits.LATA3 = pin 5)

Se estará usted preguntando, y como defino y conecto las variables virtuales a las reales?No desespere, mas adelante tratamos específicamente las variables “WEB” que se conectan con las variables “PIC”.Por el momento solo comentamos que en el main.c las líneas:

#define Boton_LED1 0 #define Boton_LED2 1

Definen el valor de retorno, es decir que cuando llegue el mensaje Boton_LED1 llegará un Byte conteniendo el valor 0x00.

La función HTTPGetVar es la encargada de actualizar los datos en la pagina de acuerdo al estado de nuestro hardware. Debe quedar claro que esta función no cambia nada en el hardware solo lee su estado y lo transmite a la web para que esta lo muestre de acuerdo a lo que se desee ver.Su prototipo es como sigue:

WORD HTTPGetVar(BYTE var, WORD ref, BYTE* val)

Donde:• Byte var es el identificador web %xx . (Variable virtual)• Word ref es donde se informa si es el primer llamado y se indica cuando es el último

mediante el envío de HTTP_END_OF_VAR.• Byte val es el byte transmitido, esta función solo transmite bytes es por esto que es necesario

indicar cuando se ha finalizado de trasmitir datos.

Dentro de esta función encontramos por ejemplo:...

switch(var){ // Se identifica la variable virtual que puede ser 0 o 1 en // este caso puntual ya que las variables son solo dos.

case LED_1: *val = LED1_IO ? '1':'0'; // Cambia el estado en la web de acuerdo al break; // del pin.

case LED_2: *val = LED2_IO ? '1':'0'; break;

...

return HTTP_END_OF_VAR; // Se indica que terminó!!

Observe las siguientes líneas:


switch(var){ <------ var es la variable virtual que llega desde la web que case LED_1: en este caso puede ser 0 o 1 ya que solo son dos var. *val = LED1_IO ? '1':'0'; <---- De acuerdo al estado del pin LEDO_IO se

se cambia su representación web.

Entonces redondeando la idea decimos que HTTPExecCmd recibe información desde la web y HTTPGetVar es la encargada de trasmitir a la web lo que está pasando en el hardware, podríamos hacer una mala comparación diciendo que una es la clásica función de recepción y la otra la función de transmisión similar a las que usamos en otros tipos de comunicaciónes (RS232, etc).

Web´s embebidas y las paginas CGI.

Las siglas CGI proceden del inglés Common Gateway Interface. Sin profundizar demasiado en el significado del acrónimo CGI, podemos decir que se trata de un mecanismo que permite que un servidor web invoque la ejecución de un programa en el propio servidor, y le pase ciertos parámetros de entrada obtenidos de una página HTML y contenidos en campos de un formulario.Por ejemplo:

• Recoger información en la página y enviarla al servidor: por ejemplo, espera que el usuario oprima un boton para cambiar el estado de un LED.

• Presentar el valor de una temperatura de forma dinámica en una página: almacenar el dato en una base de datos y mostrarlos de forma dinámica, en función de ciertos datos introducidos por el visitante en un formulario.

Actualmente, el uso de los CGIs en los entornos informáticos ha decaído con la llegada de nuevas tecnologías (como el lenguaje Java y los ASPs). Sin embargo, para determinados propósitos con microcontroladores son todavía el modo más simple y práctico de trabajar con webs dinámicas.

Las páginas CGI son la interfaz entre nuestra web y la Electrónica, a través de ellas las variables Web´s se conectan con el Hardware.

Dentro del servidor HTTP hay un pequeño módulo CGI con el propósito de que el servidor entienda estas páginas que intercambian información en tiempo real con el microcontrolador. Este pequeño módulo permite tener una gran cantidad de variables que permiten interactuar con el sistema, si bien es verdad que el microcontrolador dispone de una pequeña cantidad de memoria RAM esta cantidad de memoria es suficiente para nuestras aplicaciones. Este módulo permite interactuar con el usuario mediante la función GET() contenida en los navegadores. No vamos a desarrollar aquí como hacer CGI´s (necesitaríamos mucho, mucho tiempo).


Nuestro propósito es aprender a utilizar los que tenemos a nuestra disposición.Tomemos como ejemplo la pagina index.htm,el punto de entrada del web server que usaremos como ejemplo en este curso.

Veamos un ejemplo.Este es el aspecto de una pagina vista en el navegador y conectada a nuestro microcontrolador.

Tenemos aquí el despliegue de información proveniente del microcontrolador, estado de los pulsadores, estado de los LED´s y el conversor A/D. Pero como llega esta información hasta la pantalla web?La respuesta viene con el archivo status.cgi que es el encargado de actualizar en nuestra web la información que viene del hardware.

Las acciones ocurrirán de la siguiente forma, cuando el usurario oprima uno de los botones en la web, esta informará del cambio a través del archivo index.htm, el microcontrolador que cambiará el estado del pin correspondiente y le enviará a nuestra página información para que actualice los binarios de LED´s, esto lo hace con status.cgi.

Todo este gran intercambio de información se realiza de manera dinámica (no es necesario actualizar la página con F5 para ver los cambios) esto debido a la tecnología AJAK, sin embargo está claro que debe existir una correspondencia entre las variables mostradas en la web y las que maneja nuestro controlador.Para entender como funciona veamos la siguiente imagen.


Vemos que por ejemplo la secuencia de LED´s esta en realidad formado por %00 %01 %10 %11 %12 y dentro de nuestro archivo main.c encontramos:

#define LED0 (0x00)#define LED1 (0x01)#define LED2 (0x10)#define LED3 (0x11)#define LED4 (0x12)

etc .......................

He ahí la definición dentro del main de cada uno de los bit´s y en la pagina el lugar donde se mostrarán, el estado de cada bit será substituido según el nombre declarado por su valor hardware.El canal analógico por ejemplo definido de la siguiente manera:

#define VAR_ANAIN_AN0 (0x02)

Podemos ver en la web donde se mostrará.También tenemos las declaraciones de los botones LED1,........LED4

#define Boton_LED1 (0x0) Activa el pin 5#define Boton_LED2 (0x1) Activa el pin 8#define Boton_LED3 (0x2) Activa el pin 28#define Boton_LED3 (0x3) Activa el pin 29

No confundir los botones web que cambian el estado de los LED´s con Buttons que son los pulsadores físicos colocados en el microcontrolador y cuyo estado vemos con las variables virtuales %0F, %0E,%0D, %04.


Para detectar el momento en que el usuario oprime uno de los botones tenemos que mirar dentro del archivo index.htm, vemos unas líneas de código que haciendo referencia a los valores declarados en el main.c recogen el estado de estos botones.

Líneas dentro del archivo index.htm...

<p><font color="#156f4f" size="3"><b>Comando</b><br></font><font color=#6c6c6c size=2><br>Estado de LEDs <br></input></input>

<input onclick="GetServerFile('0?0=LED1','')" value="LED1" type="button"><input onclick="GetServerFile('0?1=LED2','')" value="LED2" type="button"><input onclick="GetServerFile('0?2=LED3','')" value="LED3" type="button"><input onclick="GetServerFile('0?3=LED4','')" value="LED4" type="button">

Identificadores en el Identificador en Web Server (main.c) la pagina web.

#define Boton_LED1 0etc, etc

Función del Navegador

Boton (input) se detecta el evento onclick para cambiar de estado los led´s.

Líneas dentro del archivo Status.CGI...<td>LEDs:</td> <td>%12 %11 %10 %01 %00</td></tr>

Identificadores en el Web Server (main.c) ej. #define LED_4 (0x12)

Como se puede ver cada elemento en la web es una “representación” de una variable física declarada en el main.c y para poder trabajar con ellas en la web podemos valernos de un programa simple como es PageBreeze.Supongamos que buscamos editar el archivo status.cgi para agregar o cambiar alguna variable que se muestra en nuestro sitio web.Recuerde que las variables llegan a través de status.cgi que es nuestro enlace entre el hardware y el navegador web.

Observe la imagen siguiente.


Este es el aspecto de status.cgi visto con el editor web. Observe que vemos claramente las variables mostradas y su identificador incluso el rotulo que veremos junto a la variable.Si quiero agregar, borrar o cambiar el orden en que se muestran es tan simple como trabajar con un editor, de la misma forma podemos editar index.htm y luego salvar lo hecho y compilar con MPFS.exe. Recuerde que el estado de los LED´s y el conversor A/D llegan a través de status.cgi por lo tanto no los verá si edita index.htm estas variables están en status.cgi, todo lo que llega desde el PIC llega a través de status.cgi.

Cuando termine de editar los archivos verifique los archivos que han quedado dentro de la carpeta que va a compilar con MPFS puesto que muchas veces se crean archivos temporales que son guardados dentro de la misma carpeta y por ende ocupan espacio, bytes inútiles que serán escritos dentro de la memoria.

El compilador MPFS.Microchip PIC File System es el sistema de archivos que utiliza el micro para leer la pagina web.


Una vez que tenemos nuestro sitio terminado con los archivos html, jpg o gif debemos convertirlos al sistema MPFS para luego poder cargarlos en el micro.La aplicación MPFS.exe convierte el conjunto de archivos que componen la pagina web a dos formatos posibles:

• .bin (Para cargar el website en la memoria EEPROM externa).• .c (Para cargar el website en la memoria de programa).

En este trabajo estamos usando la versión clásica del MPFS (Existe una mas reciente llamada MPFS2 no compatible con este trabajo).La versión clásica del MPFS funciona bajo línea de comando y es muy simple como se puede ver en la imagen anterior.La sintaxis de uso para MPFS seria: mpfs dir_origen archivo destino /b si quiero un binario para memoria exterior, mpfs dir_origen archivo destino /c si coloco el sitio en memoria FLASH.


Archivos Compilados

Tamaño en Bytes siempre menor o igual al tamaño total de la memoria a usar

Sintaxis de MPFS

MPFS compila carpetas, por lo tanto es cómodo meter todos los archivos en una carpeta y luego simplemente compilar la carpeta entera que derivara en un único archivo que enviaremos a la memoria, debe verificar el tamaño de este archivo con respecto a la capacidad de su memoria ya que MPFS no sabe de tamaños ni memorias, solo compila la carpeta que le indique.

No olvidar que la actualización de los sitios via FTP solo es posible si el sitio está en memoria exterior.

No espere ver desde su cliente FTP el contenido de la memoria 25xx ya que el formato MPFS no es comprensible para su cliente FTP .

Se debe tener presente que la construcción de los sitios web embebidos dentro de la memoria de programa de los microcontroladores consume mucha memoria, PIC´s como el 18F452, 18F4550, etc, no son muy adecuados por la poca memoria que poseen, para trabajar con web´s en memoria de programa, debemos pensar en micros como el PIC18F4620 como mínimo ya que tiene los recursos de memoria para implementar web´s en memoria FLASH.La decisión de usar la memoria FLASH o una memoria exterior para contener el sitio web depende de los requerimientos de memoria que tenga nuestra aplicación.Un sitio web básico puede consumir rápidamente la memoria del controlador es por esto que se decide alojar el sitio en una memoria exterior rápida como las modernas 25xx. Dada la gran velocidad de estas memoria nuestro sistema no se ve afectado por mermas en el rendimiento.

El servidor HTTP usa el archivo “index.htm” como página Web por defecto. Todas las aplicaciones deben incluir un archivo “index.htm” como parte de la imagen MPFS.

De igual manera es de gran importancia asegurarse que ninguno de los nombres de otras páginas Web a usar contenga alguno de los siguientes caracteres alfanumérico:

• Comillas simples o dobles ( ‘ y “ )• Corchetes y llaves ( [, {, ] y } )• Corchetes angulares ( < y > )• El signo de número ( # )• El signo de porcentaje ( % )• El símbolo “pipe” ( | )• La barra invertida ( \ )• El acento circunflejo ( ^ )• La tilde ( ~ )

Si un archivo contiene cualquiera de estos caracteres, la página Web correspondiente se volverá inaccesible y ninguna advertencia previa será mostrada. El servidor también contiene una lista de los archivos que son soportados, usando esta información para avisar al explorador remoto como interpretar un archivo en particular,basado en una extensión de un archivo de tres letras. Por defecto el servidor soportalos archivos “.txt”, “.htm”, “.gif”, “.cgi”, “.jpg”, “.cla” y “.wav”. Una aplicación no puede usar tipos de archivo que no están incluidos en esta lista.

En la actualidad existen una gran variedad de tecnologías, protocolos, herramientas y software que son utilizadas para una infinidad de aplicaciones. El conjunto de todo ello es conocido como “Tecnologías Web”. Estas tecnologías son desarrolladas por distintas empresas, organizaciones o


público en general, sin embargo todas son supervisadas por el World Wide Web Consortium (W3C), que desarrolla protocolos,estándares y lineamientos para asegurar el correcto funcionamiento y crecimiento de la Web. Algunas tecnologías Web más utilizadas son las siguientes:

• HTTP CGI• HTML Dinámico• JavaScript• AJAX• CSS2.10.1 • HTTP CGI

Un servidor HTTP puede dinámicamente alterar páginas y sustituir información en tiempo real, tal como status de entrada y salida. Para incorporar información en tiempo real, el archivo CGI correspondiente debe contener una cadena de texto ‘%xx’, donde el carácter ‘%’ sirve como código de control y ‘xx’ representa una variable identificadora de dos dígitos. El valor de variables tiene un rango de 00-99. Cuando el servidor HTTP encuentra esta cadena de texto, se remueve el carácter ‘%’ y llama la función HTTPGetVar(). Esta función realiza un llamado HTTP, cuando el servidor HTTP encuentra una cadena ‘%xx’ en una página CGI en servicio se llama a esta función. HTTPGetVar() es usada en la aplicación principal del usuario y transfiere una variable de estatus específica de HTTP.

Una ves que nuestro proyecto ha sido compilado y nuestro micro programado con el código podemos probar su funcionamiento haciendo un ping a la dir IP 192,168,1,201 o firtec_tcp que es el identificador red que le dimos a nuestro ejercicio.

Perfecto, estamos conectados!!

Comentarios finales.

Como seguramente abra notado, la mayor dificultad que tiene la implementación del Stack de Microchip (en rigor de verdad todos) es la gran cantidad de variables en juego.


Variables virtuales web, variables en el PIC, enlaces CGI, y todo esto funcionando en sincronía.También habrá notado que no hemos hablado de tiempos, de cuanto tiempo dispongo para mis funciones y que pasa con las interrupciones?

Solo hemos dado el puntapié inicial, hemos establecido contacto entre nuestro navegador web y el PIC y si lo piensa en función de prestaciones comerciales el campo de aplicaciones es muy extenso.

Podríamos conectar una alarma a internet y que el propio usuario haga el monitoreo, o podemos hacer un desarrollo muy complejo en donde nuestro cliente solo “ve” por lo que pagó y a medida que “compra” mas servicios disponibles dentro de nuestro micro le vamos actualizando las web's y haciendo visibles estos servicios.Una vez que nuestro sistema está en la red el alcance es la propia imaginación.

Está claro que para hacer visible el sistema en Internet debemos contar con una IP fija o usar algún artilugio para que nuestro dispositivo siempre publique su IP, esto ya es una cuestión del tipo de proveedor que usted tenga y el tipo de servicio.

En el próximo capitulo seguimos avanzando con los temas que han quedado pendientes y sumando funcionalidades a nuestro PIC-Ethernet.


mailto:[email protected]

Mi primer WEB - firteconline.com.arfirteconline.com.ar/C18/web1.pdf · debe entender que para poder...

Documents

Transcript of Mi primer WEB - firteconline.com.arfirteconline.com.ar/C18/web1.pdf · debe entender que para poder...