main.c

用MCS51 单片机的TCIP协议的测试,很基本的程序,对新手可能有帮助!

/*
********************************************************************************
* Wiznet.
* 5F Simmtech Bldg., 228-3, Nonhyun-dong, Kangnam-gu,
* Seoul, Korea
*
* (c) Copyright 2002, Wiznet, Seoul, Korea
*
* Filename      : Main.c
* Programmer(s) : 
* Version       : 1.0 
* Created       : 2002/08/05
* Modified      :
* Description   : 
********************************************************************************
*/
#include "config.h"
#include "serial.h"		
#include "socket.h"		
#include "remote.h"
#include "eeprom.h"
#include "dhcp.h"
#include "init.h"
#include "netconfig.h"
#include "flowctrl.h"
#include <string.h>


/*********************** Gloval variable ***********************/
u_char xdata Mac[6] 							_at_ 0x07ff5;
u_char xdata sock_buf[MAX_BUF_SIZE] 			_at_ 0x6800;		// Rx Buffer Address
u_char xdata sio_buf[MAX_SBUF_SIZE] 			_at_ 0x7000;
u_char xdata temp_sio_buf[(MAX_SBUF_SIZE/2)] 	_at_ 0x7800;

u_char xdata sock_state[MAX_SOCK_NUM];	

// socket
u_char xdata m_bConnectSvr = 0;
u_char xdata m_bConnectCli = 0;
u_int  xdata clientport = 0;

// data pointer
u_int xdata wr_ptr = 0;
u_int xdata read = 0;
u_int xdata write = 0;
u_int xdata tmp_cnt = 0;
u_int xdata data_cnt = 0;

// delimiter 
u_char xdata D_ch = 0;
u_int  xdata D_size = 0;
u_int  xdata D_time = 0;
u_int  xdata D_time_cnt = 0;
u_int  xdata I_time = 0;
u_int  xdata I_time_cnt = 0;
u_char xdata closeOK = 0;
u_int xdata DCH_Wptr = 0;

// Keep alive timer
u_int xdata K_time = 0;

// DHCP
extern un_l2cval xdata lease_time;
extern u_long xdata my_time;
u_char xdata lease_time_cnt = 0;

u_char Flow_Ctrl = 0;
u_char buffer_full = 0;
u_char Stop_Sending = 0;
u_char S_datasize;
u_char S_Parity;

bit C_sendOK = 0;
bit T_sendOK = 0;
bit D_sendOK = 0;

bit TI_FLAG;
bit DHCPisSuccess;
bit DHCPisSet;
bit Enable_DHCP_Timer;
bit Debug_Off;
bit m_bServer;
bit m_bSetted;
bit Enable_SP;

extern int xdata SSIZE[MAX_SOCK_NUM];         // Maximun Tx memory size by each channel

/*_____________________________________________________________________________*/

char parseConfMSG(SOCKET s,u_int length);
void init_sock(u_char i);				  
int Net_Upgrade(void);

/*
********************************************************************************
* Description : 8051 Timer0 Interrupt Service Routine
* Arguments   : None
* Returns     : None
* Note        : 
********************************************************************************
*/
static void timer0(void) interrupt 1
{
	
	EA = 0;
	TR0 = 0;
	TL0 += (TIMER0_COUNT & 0x00FF);
	TH0 += (TIMER0_COUNT >> 8);
	
	// for delimeter 
	if (D_time != 0)
	{
		D_time_cnt++;
		if (D_time_cnt >= D_time)
		{
			T_sendOK = 1;
			D_time_cnt = 0;
		}
	}
	// for Idle time close function
	if (I_time != 0)
	{
		I_time_cnt++;
		if (I_time_cnt >= I_time)
		{
			closeOK = 1;
			I_time_cnt = 0;
		}
	}
	
	// for DHCP
	if (Enable_DHCP_Timer == 1) {
		lease_time_cnt++;
		if (lease_time_cnt == 0x50) {
			lease_time_cnt = 0;
			my_time++;
		}
	}
	
	// for Keep alive packet	
	if ((m_bConnectSvr == 1) || (m_bConnectCli == 1)) {
		K_time++;
		if (K_time > 30000) { // about 5 min 30 sec
			K_time = 0;
			Enable_SP = 1;
		}
	}
	
	TR0 = 1;
	EA = 1;
}

/*
********************************************************************************
* Description : 8051 Serial Interrupt Service Routine
* Arguments   : None
* Returns     : None
* Note        : 
********************************************************************************
*/
void Serial_Int(void) interrupt 4 
{
	EA = 0;
	
	if (RI) 
	{	
		if (S_datasize == 7) sio_buf[write] = (SBUF & 0x7F);
		else sio_buf[write] = SBUF;
		
		I_time_cnt = 0 ;
		if ( D_ch != 0 )
		{	
			if ( sio_buf[write] == D_ch ) {
				C_sendOK = 1;
				DCH_Wptr = write + 1; // Backup
			}
		}
		if (Flow_Ctrl == F_XON) {
			if (sio_buf[write] == XON) Stop_Sending = 0;
			if (sio_buf[write] == XOFF) Stop_Sending = 1;
		}
		write++;
		if(write >= MAX_SBUF_SIZE) write = 0;
		RI = 0;
	}
	
	if (TI) {
		TI_FLAG = 1;
		TI = 0;
	}
	
	EA = 1;
}

/*
********************************************************************************
* Description : Init network from DHCP server
* Arguments   : None
* Returns     : None
* Note        : 
********************************************************************************
*/
void Init_Net_DHCP(void)
{
	u_char i;
	
	if(DHCP_SetIP()) { //DHCP success => Init Net
		DHCPisSuccess = 1;
		if (!Debug_Off) {
			PutString("> DHCP lease time = ");
			PutLTOA(lease_time.lVal);PutStringLn("");
			PutString("> DHCP Success.");
		}
	}
	else {				// DHCP Fail	=> Not init Net
		DHCPisSuccess = 0;
		if (!Debug_Off) PutString("\n\r> DHCP Fail.");
		// set default IP 0.0.0.0
		for (i = 8; i <= 21; i++)
			EEP_Write(i, 0x00);
			
	}
}

/*
********************************************************************************
* Description : Setting IIM7100's option
* Arguments   : None
* Returns     : None
* Note        : 
********************************************************************************
*/
void SetupOption(void)
{
	u_char val1, val2;
	
	// read option info
	m_bServer = (bit)(EEP_Read(EE_KIND));
	// delimeter
	D_ch = EEP_Read(EE_D_CH);
		val1 = EEP_Read(EE_D_SIZE1);
		val2 = EEP_Read(EE_D_SIZE2);
	D_size = (u_int)((val1<<8) + val2);
		val1 = EEP_Read(EE_D_TIME1);
		val2 = EEP_Read(EE_D_TIME2);
	D_time = (u_int)((val1<<8) + val2);
		val1 = EEP_Read(EE_I_TIME1);
		val2 = EEP_Read(EE_I_TIME2);
	I_time = (u_int)((val1<<8) + val2);
	
	// serial
	Flow_Ctrl  = EEP_Read(EE_FLOW);
	S_datasize = EEP_Read(EE_DSIZE);
	S_Parity   = EEP_Read(EE_PARITY);
}




/*
********************************************************************************
* Description : Ethernet to serial conversion routine
* Arguments   : None
* Returns     : None
* Note        : 
********************************************************************************
*/
void Ether2Serial(SOCKET i, u_int len)
{
	u_int j = 0;
	u_char ch;
	
	// for idle time count reset..
	EA = 0;
	closeOK = 0;
	I_time_cnt = 0;
	EA = 1;
	
	if (len > MAX_BUF_SIZE) len = MAX_BUF_SIZE;
	
	len = recv(i, sock_buf, len);
	
	for (j = 0; j < len; j++) {
		if (Flow_Ctrl == F_RTS) {
			Loopback_CTS();
			while(Check_RRTS());
		}
			ch = *(sock_buf + j);
			PutByte(ch);
			
		// Xon/Xoff
		if (Flow_Ctrl == F_XON) while(Stop_Sending);
	}
}

/*
********************************************************************************
* Description : 
* Arguments   : None
* Returns     : 
* Note        : 
********************************************************************************
*/
u_char Calc_dSize(void)
{
	u_char flag;
	
	if ((D_ch != 0) && (C_sendOK == 1)) {
		EA = 0;
		  wr_ptr = DCH_Wptr;
		EA = 1;
	}
	
	if (wr_ptr == read) {
		return(2);
	}

	if (wr_ptr > read) {
		data_cnt = wr_ptr - read;
		flag = 0;
	}
	else if (wr_ptr < read) {
		tmp_cnt = MAX_BUF_SIZE - read;
		data_cnt = tmp_cnt + wr_ptr;
		flag = 1;
	}
	
	if ( D_size != 0 ) {
		if ((data_cnt >= MAX_SEND_SIZE) || (data_cnt >= D_size)) {
			D_sendOK = 1;
		}else {
			D_sendOK = 0;
		}
		
	}
	return(flag);
}

/*
********************************************************************************
* Description : Serial to Ethernet conversion routine
* Arguments   : i - socket number
* Returns     : None
* Note        : 
********************************************************************************
*/
void Serial2Ether(SOCKET i)
{
	u_char flag;

	
	flag = Calc_dSize();
	if (flag == 2) return;
	
	if (Flow_Ctrl == F_XON) {
		buffer_full = Check_XonOff(buffer_full, data_cnt);
	}
	
	if ( D_ch == 0 && D_size == 0 && D_time == 0 ) { 
		if (flag) {
			memcpy(&temp_sio_buf[0], &sio_buf[read], tmp_cnt);
			memcpy(&temp_sio_buf[tmp_cnt], &sio_buf[0], wr_ptr);
			send(i, &temp_sio_buf[0], data_cnt);
			
			read = wr_ptr;
		}
		else {
			send(i, &sio_buf[read], data_cnt);
			read += data_cnt;
		}
	}
	else  // any delimeter is set
	{
		if (C_sendOK == 1) {
			flag = Calc_dSize();
			if (flag) {
				memcpy(&temp_sio_buf[0], &sio_buf[read], tmp_cnt);
				memcpy(&temp_sio_buf[tmp_cnt], &sio_buf[0], wr_ptr);
				send(i, &temp_sio_buf[0], data_cnt);
				
				read = wr_ptr;
			}
			else {
				send(i, &sio_buf[read], data_cnt);
				read += data_cnt;
			}
			D_sendOK = 0;
			C_sendOK = 0;
			T_sendOK = 0;
		}
	
		if (D_sendOK == 1) {
			flag = Calc_dSize();
			if (flag == 2) return;
			if (flag) {
				if (tmp_cnt > D_size) {