www.pudn.com > tcpip5151.rar > Main.c

//--------------------------------------------------------------------------- 
// Net MAIN.C 
// 
// 8051 Web Server project 
// See Makefile for build notes  
// Written for Keil C51 V5.1 compiler, notes: 
//   It uses big endian order, which is the same as the 
//   network byte order, unlike x86 systems. 
//   Use OPTIMIZE(2)or higher so that automatic variables get shared 
//   between functions, to stay within the 256 bytes idata space 
//--------------------------------------------------------------------------- 
 
#include  
#include  
#include  
#include  
#include "net.h" 
#include "eth.h" 
#include "serial.h" 
#include "timer.h" 
#include "analog.h" 
#include "arp.h" 
#include "tcp.h" 
#include "http.h" 
#include "ip.h" 
 
 
// Global variables 
UINT volatile event_word; 
char xdata text[20];   
UCHAR idata debug; 
UCHAR idata rcve_buf_allocated; 
 
 
// This sets my hardware address to 00:01:02:03:04:05 
UCHAR code my_hwaddr[6] = {0x08, 0x07, 0x06, 0x05, 0x04, 0x03};  
 
// Hardware addr to send a broadcast 
UCHAR code broadcast_hwaddr[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; 
 
// This sets my IP address to 192.168.0.10 
ULONG code  my_ipaddr = 0x0A0154FDL; 
 
// This sets my subnet mask to 255.255.255.0 
ULONG code my_subnet = 0xFFFFFF00L; 
 
// Set to 0 if no gateway is present on network 
ULONG code gateway_ipaddr = 0x0A015401L; 
 
//-------------------------------------------------------------------------- 
// Initialize the memory management routines 
// Initialize variables declared in main 
//-------------------------------------------------------------------------- 
 
unsigned int Count1msInc; 
unsigned char Count1ms,Count10ms,Count1s; 
unsigned char TimeSecond,TimeMinute; 
 
void init_main(void) 
{ 
	// Start the memory pool for incoming and outgoing Ethernet 
	// frames at 1000, with length = 1500 bytes. Memory below 500 
	// is used for program variables 
	init_mempool((void xdata *)1000, 1500); 
	memset(text, 0, sizeof(text)); 
	event_word = 0; 
	rcve_buf_allocated = FALSE; 
	debug = 1; 
} 
 
 
 
void Timer_Init (void) 
{ 
 	TMOD = 0X11; 
	TF0 = 0; 
	TH0 = 0XF8;   		// set Timer0 to overflow in 1ms 
   	TL0 = 0X30; 
   	TR0 = 1;   	// START Timer0 
	ET0 = 1; 
	TF1=0; 
	TH1=0X4C; 
	TL1=0; 
	TR1=1; 
	ET1=1; 
} 
 
void Timer0_ISR (void) interrupt 1  //1ms 
{ 
	TH0 = 0XF8;   
   	TL0 = 0X30; 
	if (Count1ms) Count1ms--; 
	Count1msInc++; 
	if (Count10ms) Count10ms--; 
	else 
	{ 
		Count10ms=10;    			//10ms 
		if (Count1s) Count1s--; 
		else 
		{ 
			Count1s=100;			//1s 
			TimeSecond++; 
			if (TimeSecond>=60) 
			{ 
				TimeSecond=0;		//1min 
				TimeMinute++; 
				if	(TimeMinute==60)	TimeMinute=0; 
			} 
		} 
	} 
} 
 
 
void Delay1ms(unsigned char T) 
{ 
	Count1ms=T; 
	while (Count1ms); 
} 
 
 
 
 
 
void LightONOFF(bit b) 
{ 
if (b) { 
	P1=254; 
	} 
	else 
	{ 
	P1=255; 
	} 
} 
 
 
void main (void) 
{ 
	UINT j, event_word_copy; 
	UCHAR xdata * inbuf; 
                    	 
 
 
	Timer_Init(); 
 
 
	init_main(); 
	init_tcp(); 
	init_http(); 
 
	EA=1; 
	init_serial(); 
	if (debug) printf("Init OK!\n"); 
 
	init_arp(); 
	init_8019(); 
    
	 
 
	j = 0; 
 
	   	 
   // The code below is a priority based RTOS.  The event 
   // handlers are in priority order - highest priority first. 
	while (1) 
   { 
      // Query CS8900A to see if Ethernet frame has arrived 
      // If so, set EVENT_ETH_ARRIVED bit in event_word 
      query_8019(); 
       
      // Use a copy of event word to avoid interference 
      // with interrupts 
		EA = 0; 
		event_word_copy = event_word; 
		EA = 1; 
       
      // See if an Ethernet frame has arrived       
      if (event_word_copy & EVENT_ETH_ARRIVED) 
      { 
         EA = 0; 
         event_word &= (~EVENT_ETH_ARRIVED); 
         EA = 1; 
          
         // Allocate a buffer and read frame from CS8900A 
         inbuf = rcve_frame(); 
         if (inbuf != NULL) 
         { 
            // Process the received Ethernet frame  
            eth_rcve(inbuf);  
          
            // If the memory allocated for the rcve message has 
            // not already been freed then free it now 
            if (rcve_buf_allocated) 
            { 
               free(inbuf); 
               rcve_buf_allocated = FALSE; 
            } 
         } 
      } 
       
      // See if TCP retransmit timer has expired            	        
      else if (event_word_copy & EVENT_TCP_RETRANSMIT) 
      { 
         EA = 0; 
         event_word &= (~EVENT_TCP_RETRANSMIT); 
         EA = 1; 
         tcp_retransmit(); 
 		} 
 
      // See if TCP inactivity timer has expired 
      else if (event_word_copy & EVENT_TCP_INACTIVITY) 
      { 
         EA = 0; 
         event_word &= (~EVENT_TCP_INACTIVITY); 
         EA = 1; 
         tcp_inactivity(); 
 		} 
 
      // See if ARP retransmit timer has expired 
 		else if (event_word_copy & EVENT_ARP_RETRANSMIT) 
      { 
         EA = 0; 
         event_word &= (~EVENT_ARP_RETRANSMIT); 
         EA = 1; 
         arp_retransmit(); 
		} 
 
      // See if it is time to age the ARP cache 
      else if (event_word_copy & EVENT_AGE_ARP_CACHE) 
      { 
         EA = 0; 
         event_word &= (~EVENT_AGE_ARP_CACHE); 
			EA = 1; 
         age_arp_cache(); 
		} 
 
		// See if it is time to read the analog inputs 
		else if (event_word_copy & EVENT_READ_ANALOG) 
      { 
         EA = 0; 
         event_word &= (~EVENT_READ_ANALOG); 
         EA = 1; 
			// Read one of the 3 analog inputs each time 
			read_analog_inputs(); 
      } 
 
		// See if an RS232 message has arrived.  It is 
      // not handled - RS232 is used for sending only 
		else if (event_word_copy & EVENT_RS232_ARRIVED) 
      { 
         EA = 0; 
         event_word &= (~EVENT_RS232_ARRIVED); 
         EA = 1; 
      } 
   } 
}