//-----------------------------------------------------------------------------
// Net SERIAL.C
//
// This module handles RS-232 messages and associated tasks
//-----------------------------------------------------------------------------
#include "AT89X52.h"
#include "intrins.h"
#include "net.h"
#include "serial.h"

bit CommRecDataOverflowFlag,FlagRecComm,SendItComm;

unsigned char CommSendBufferHead, CommSendBufferTail;
unsigned char CommRecBufferHead, CommRecBufferTail;

unsigned char xdata CommSendBuffer[DB_SENDMAXSIZE] _at_ 0 ; //4K XRAM
unsigned char xdata CommRecBuffer[DB_RECMAXSIZE] _at_ DB_SENDMAXSIZE; 
 
void ClearCommRecBuffer(void)
{
	unsigned char i;
	CommRecBufferHead=CommRecBufferTail=0;
	CommSendBufferHead=CommSendBufferTail=0;
	FlagRecComm=0;
	for (i=0;i<DB_SENDMAXSIZE;i++)
	{
		CommSendBuffer[i]=0;
	}
	for (i=0;i<DB_RECMAXSIZE;i++)
	{
		CommRecBuffer[i]=0;
	}
}

void init_serial(void)
{
	ClearCommRecBuffer();
	OpenComm();
}

void OpenComm(void) 
{
	PCON |= 0x80;		// SMOD=1 (HW_UART uses Timer 1 overflow with no divide down).
	TMOD |= 0x20;		// Configure Timer 1 for use by UART0
    TH1=0XFF;           // 115200 FOR 22.1184MHZ
    TL1=0XFF;
    TR1=1;

	CommSendBufferHead=CommSendBufferTail=0; // set the head and tail to the base of the ring buffer
	CommRecBufferHead=CommRecBufferTail=0;
	FlagRecComm=0;
	RI=0;					// Clear HW_UART receive and transmit
	TI=0;					// complete indicators.
	SCON = 0x50;			// Configure UART0 for mode 1, receiver enabled.
	ES=1; 					// allow the serial interrupt
	SendItComm=1;
}
/*
void SendCommChar(char ch)
{
	CommSendBuffer[CommSendBufferTail]=ch; 
	CommSendBufferTail++;
	if (CommSendBufferTail==DB_SENDMAXSIZE)
	{ 	
		CommSendBufferTail=0;
	}
	if (SendItComm)
	{	 
		SendItComm=0;
		SBUF0=CommSendBuffer[CommSendBufferHead]; 
	}
	while (CommSendBufferHead!=CommSendBufferTail);
	return ;
}

code unsigned char hex[]="0123456789ABCDEF";
void SendCommHex(unsigned char senddata)//hex senddata=0x3A '3','A' hex[]
{
	unsigned char ch;
	ch=senddata>>4;
	SendCommChar(hex[ch]);
	ch=senddata&0x0F;
	SendCommChar(hex[ch]);
}
void SendCommWord(unsigned int asciiword)
//int  hex asciiword=0x124D 4 '1','2','4','D'
{
	unsigned char ascii;
	ascii=asciiword>>8;
	SendCommHex(ascii);
	ascii=asciiword&0xff;
	SendCommHex(ascii);
}

void SendCommLong(unsigned long asciilong)
{
	SendCommWord(asciilong>>16);
	SendCommWord(asciilong&0xffff);
}
*/
void serial_send(unsigned char *base)
{
	SendCommString(base);
}

void SendCommString(unsigned char *base) 
{
unsigned char i=0;
	if (base[0]==0) return;
	for (;;)
	{	
		if (base[i]==0) break;
		CommSendBuffer[CommSendBufferTail]=base[i]; 
		CommSendBufferTail++; 
		if (CommSendBufferTail==DB_SENDMAXSIZE)
		{ 						
			CommSendBufferTail=0;
		}
		i++;
	}
	if (SendItComm)
	{	 						
		SendItComm=0;
		SBUF=CommSendBuffer[CommSendBufferHead];
	}
	while (CommSendBufferHead!=CommSendBufferTail);
}
/*
void SendCommBuffer(unsigned char *base, unsigned char size) 
{
unsigned char i=0;
	if (!size) { return; }	
	while (i<size) 
	{	 
		CommSendBuffer[CommSendBufferTail]=base[i]; 
		i++;
		CommSendBufferTail++; 
		if (CommSendBufferTail==DB_SENDMAXSIZE)
		{ 
			CommSendBufferTail=0;
		}
	}
	if (SendItComm)
	{	 
		SendItComm=0;
		SBUF0=CommSendBuffer[CommSendBufferHead]; 
	}
}
*/
void CommISR(void) interrupt 4
{
	if (_testbit_(TI))
	{
		TI=0;
		CommSendBufferHead++; 	
		if (CommSendBufferHead==DB_SENDMAXSIZE)
		{	 
			CommSendBufferHead=0;
		}
		if (CommSendBufferHead!=CommSendBufferTail)
		{	 
			SBUF=CommSendBuffer[CommSendBufferHead]; // send the next byte
			SendItComm=0;
		}
		else
		{
			SendItComm=1;
		}
	}
	if (_testbit_(RI))	
	{	 
		RI=0;
		if (CommRecBufferTail==CommRecBufferHead)
		{
			CommRecDataOverflowFlag=1;				//
		}
		CommRecBuffer[CommRecBufferTail]=SBUF;     //receive data           
	    CommRecBufferTail++;
	    if (CommRecBufferTail==DB_RECMAXSIZE)
	    {
	    	CommRecBufferTail=0;
	    }
		FlagRecComm=1;
   	}
}

//
/*
bit GetCommChar(unsigned char idata *ch)      
{ 
	if (CommRecBufferTail==CommRecBufferHead) return 0;     
	*ch=CommRecBuffer[CommRecBufferHead];
	CommRecBufferHead++;
	if (CommRecBufferHead==DB_RECMAXSIZE)
	{
		CommRecBufferHead=0;
	}
	if (CommRecBufferTail==CommRecBufferHead) FlagRecComm=0;
	return 1;
}
*/
/*
//T(0-255) 0,1
bit GetCommCharWait(unsigned char idata *ch,unsigned char T)  //T ms    
{ 
	Count1ms=T;*ch=0;
	while (Count1ms)
	{
		if (CommRecBufferTail!=CommRecBufferHead) break;
	}
	if (Count1ms==0) return 0;
	*ch=CommRecBuffer[CommRecBufferHead];
	CommRecBufferHead++;
	if (CommRecBufferHead==DB_RECMAXSIZE)
	{
		CommRecBufferHead=0;
	}
	return 1;
}
*/

//------------------------------------------------------------------------
// This function converts an integer to an ASCII string.  It is a 
// normally provided as a standard library function but the Keil
// libraries do not include it.  Caution: The string passed to this
// must be at least 12 bytes long
//------------------------------------------------------------------------
char * itoa(UINT value, char * buf, UCHAR radix)
{
	UINT i;
	char * ptr;
	char * temphold;

  	temphold = buf;
	ptr = buf + 12;
	*--ptr = 0;		// Insert NULL char
	do
	{
	   // First create string in reverse order
	   i = (value % radix) + 0x30;
		if(i > 0x39) i += 7;
		*--ptr = i;
      value = value / radix;
  	} while(value != 0);

	// Next, move the string 6 places to the left
	// Include NULL character
	for( ; (*buf++ = *ptr++); );	
	return(temphold);
}