vdipnew.c

interfacing of vdip module with 89c52

#include <REGX52.h>
//*****************************************************************************************
//  
//  Constants and variables for serial port
//  
//*****************************************************************************************
// Define serial port flags
char _CTS = 0x04;											// RTS# is PORT3 PIN 2
char _RTS = 0x08;											// CTS# is PORT3 PIN 3
char FLOW_NONE = 0x00;	
char FLOW_RTS_CTS = 0x01;
char FLOW_CONTROL_ENABLED = 0x00;							// Initialise FLOW_CONTROL_ENABLED to off

// Define serial port Rx buffer variables
char SERIAL_RX_FIFO[0x20];									// Allocate buffer for RX FIFO USE MULTIPLE OF 0x04!
char RX_FIFO_SIZE = sizeof(SERIAL_RX_FIFO);					// Initialise FIFO size variable
char RX_FIFO_COUNT = 0x00;									// Reset RX FIFO count
char * RX_FIFO_HEAD_PTR = &SERIAL_RX_FIFO[0x00];			// Initialise head pointer 
char * RX_FIFO_TAIL_PTR = &SERIAL_RX_FIFO[0x00];			// Initialise tail pointer
char * RX_FIFO_START = &SERIAL_RX_FIFO[0x00];               //RX_FIFO_TAIL_PTR;	// Set lowest address of RX_FIFO
char * RX_FIFO_END =&SERIAL_RX_FIFO[0x00] + sizeof(SERIAL_RX_FIFO);			// Set highest address of RX_FIFO
char RX_STATUS = 0x00;										// Reset RX status
char RX_FIFO_OVERRUN = 0x01;

char RX_FIFO_UPPER_LIMIT = 0x03 *(sizeof(SERIAL_RX_FIFO)/ 0x04);		// Buffer limit for handshaking
char RX_FIFO_LOWER_LIMIT = (sizeof(SERIAL_RX_FIFO) / 0x04);			// Buffer limit for handshaking
char* reset_screen = { "  PENDRIVE PROJECT :: STESALIT LIMITED  "} ; 
			  

//*****************************************************************************************
//  
//  Define states for state machine
//  
//*****************************************************************************************

enum {														// Enum states
	VNC1L_Idle,												// Idle state
	VNC1L_DiskAvailable,
	VNC1L_CreateFile,
	VNC1L_WriteFile,
	VNC1L_EndFile,
	VNC1L_WaitForRemove
};

char VNC1L_State = VNC1L_Idle;								// Initialise state to idle

char Synchronised = 0x01;
char GotDisk = 0x01;

///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
//  
//  Routines for serial port
//  
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////


//*****************************************************************************************
//  
//  Reset Rx FIFO
//  
//*****************************************************************************************
void serial_resetrxfifo()
{
    ES = 0; 						     /* Enable serial interrupt	*/
	EA = 0;						     /* Enable global interrupt */ 
	RX_FIFO_COUNT = 0x00;									// Reset FIFO count to 0
	RX_STATUS = 0x00;										// Reset FIFO status
	RX_FIFO_HEAD_PTR = (&SERIAL_RX_FIFO[0x00]);				// Set FIFO head pointer to address of first byte of SERIAL_RX_FIFO
	RX_FIFO_TAIL_PTR = (&SERIAL_RX_FIFO[0x00]);				// Set FIFO tail pointer to address of first byte of SERIAL_RX_FIFO
	ES = 1; 						     /* Enable serial interrupt	*/
	EA = 1;						     /* Enable global interrupt */
	if (FLOW_CONTROL_ENABLED == 0x01)						// If using flow control
	{
	P3_3=0;
	}
}
//*****************************************************************************************
//  
//  Initialise serial port (Baud rate, handshaking, interrupt enable, enable receiver)
//  
//*****************************************************************************************
void serial_init(long BaudRate, char Handshaking)			// Set up serial port
{
	ES = 0; 						     /* Enable serial interrupt	*/
	EA = 0;						     /* Enable global interrupt */
	P3_3=1;														// TRISC bits 1 for input, 0 for output
	SCON = 0x50;					  /* uart in mode 1 (8 bit), REN=1 */
	TMOD = TMOD | 0x20 ;         /* Timer 1 in mode 2 */
	switch (BaudRate)										// Set Baud rate
	{
		case 9600:
			TH1  = 0xFD;                 /* 9600 Bds at 11.059MHz */
	        TL1  = 0xFD; 				  	  /* 9600 Bds at 11.059MHz */
		default:
			TH1  = 0xFD;                 /* 9600 Bds at 11.059MHz */
			TL1  = 0xFD; 				  	  /* 9600 Bds at 11.059MHz */									// Default to 9600 if not a valid achievable Baud rate
	}
	TR1 = 1; 						  /* Timer 1 run */

	if (Handshaking == FLOW_RTS_CTS)
	{
		P3_3=0;
		FLOW_CONTROL_ENABLED = 0x01;						// Set flow control enabled flag
	}

	ES = 1; 						     /* Enable serial interrupt	*/
	EA = 1;	
	TI=1;
	RI=1;
	serial_resetrxfifo();									// Reset Rx FIFO
}
//*****************************************************************************************
//  
//  Send a byte directly from the transmit register
//  
//*****************************************************************************************
void serial_sendbyte(char TX_BYTE)
{
	if (FLOW_CONTROL_ENABLED == 0x01)
	{	
		while (P3_2);								// Wait for CTS# to become active (low)
	}
    	while(!TI);        

    	TI=0;
		SBUF = TX_BYTE;  										// Move byte to send into sbuf
}
//*****************************************************************************************
//  
//  Read a byte directly from the receive character register
//  
//*****************************************************************************************
void delay_ms(int i )
{
unsigned int j,k,l;
l=i;
for (j=0;j<=l;j++)
{
for (k=0;k<=500;k++)
{
;
}
}
}
void delay_s(int i )
{
unsigned int j,k,l;
l=i;
for (j=0;j<=l;j++)
{
for (k=0;k<=5000;k++)
{
;
}
}
}
//*****************************************************************************************
//  
//  Add a byte from the receive character register to the receive FIFO buffer
//  
//*****************************************************************************************
void serial_addtorxfifo()
{
	if (RX_FIFO_COUNT >= RX_FIFO_SIZE)						// If Rx FIFO is full
	{
		RX_STATUS = RX_STATUS | RX_FIFO_OVERRUN;			// Set overrun flag
		if (FLOW_CONTROL_ENABLED == 0x01)					// If using flow control
		{
		P3_3=1;
		}
		return;
	}

	if (RX_FIFO_COUNT >= RX_FIFO_UPPER_LIMIT)				// Keep some space in the FIFO for bytes already being sent
	{
		if (FLOW_CONTROL_ENABLED == 0x01)					// If using flow control
		{
		P3_3 =1;
		}
	}
	ES = 0; 						     /* Enable serial interrupt	*/
	EA = 0;						     /* Enable global interrupt */
	*RX_FIFO_HEAD_PTR++ = SBUF;							// Add received byte to RX_FIFO and then increment head pointer
	RX_FIFO_COUNT++;										// Increment byte count

	if (RX_FIFO_HEAD_PTR >= RX_FIFO_END)					// If head pointer is greater than allocated FIFO end address
	{
		RX_FIFO_HEAD_PTR = RX_FIFO_START;					// Wrap-around buffer to start address again (circuluar FIFO)
	}	

	if ((RX_FIFO_COUNT < RX_FIFO_UPPER_LIMIT) && (FLOW_CONTROL_ENABLED == 0x01))	// If Rx FIFO is not full
	{
	P3_3=0;
	}
	ES = 1; 						     /* Enable serial interrupt	*/
	EA = 1;						     /* Enable global interrupt */	
}

//*****************************************************************************************
//  
//  Read a byte out of the receive FIFO buffer
//  
//*****************************************************************************************
void serial_readfromrxfifo(char * RX_FIFO_BYTE)
{
	if (RX_FIFO_COUNT == 0)									// If FIFO is empty
	{
		return;												// Exit - no data to read
	}
	ES = 0; 						     /* Enable serial interrupt	*/
	EA = 0;						     /* Enable global interrupt */
	*RX_FIFO_BYTE = *RX_FIFO_TAIL_PTR++;					// Read a byte from the FIFO at position given by RX_FIFO_TAIL_PTR and then increment tail pointer
	RX_FIFO_COUNT--;										// Decrement byte count	
	
	if (RX_FIFO_TAIL_PTR >= RX_FIFO_END)					// If tail pointer is greater than allocated FIFO end address
	{
		RX_FIFO_TAIL_PTR = RX_FIFO_START;					// Wrap-around buffer to start address again (circuluar FIFO)
	}
	ES = 1; 						     /* Enable serial interrupt	*/
	EA = 1;						     /* Enable global interrupt */
	if ((RX_FIFO_COUNT < RX_FIFO_LOWER_LIMIT) && (FLOW_CONTROL_ENABLED == 0x01))	// If using flow control
	{
		P3_3=0;
	}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
//  
//  VNC1L VDAP commands go here
//  
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////


//*****************************************************************************************
//  
//  Echo command using E - same for short command set or long command set
//  
//*****************************************************************************************
void VNC1L_Big_E()
{
	serial_sendbyte('E');									// Send 'E'
	serial_sendbyte(0x0D);									// Send carriage return
}
//*****************************************************************************************
//  
//  Echo command using e - same for short command set or long command set
//  
//*****************************************************************************************
void VNC1L_Small_e()
{
	serial_sendbyte('e');									// Send 'e'
	serial_sendbyte(0x0D);									// Send carriage return
}
//*****************************************************************************************
//  
//  Synchronise to the VNC1L using the e and E echo commands
//  
//*****************************************************************************************
char VNC1L_Sync()
{
	char LoopCount = 0x00;
	char FIFOByte1 = 0x00;
	char FIFOByte2 = 0x00;
	char Got_Big_E = 0x00;
	char Got_Small_e = 0x00;

	serial_resetrxfifo();									// Reset FIFO before synchronising

	while ((Got_Big_E == 0x00) && (LoopCount < 0xFF))
	{
		VNC1L_Big_E();										// Send Big E echo
		LoopCount++;										// Increment loop count
		while (RX_FIFO_COUNT < 0x02)
		{
			delay_ms(100);									// Wait for 2 byte response
		}						

		if (RX_FIFO_COUNT > 0x00)							// If data is available
		{
			while (RX_FIFO_COUNT > 0x02)					// Read all data available except last 2 bytes
			{
				serial_readfromrxfifo(&FIFOByte1);			// If more than 2 bytes available, read surplus ones
					
			}
			serial_readfromrxfifo(&FIFOByte1);				// Check that remaining 2 bytes are 'E' and 0x0D
			serial_readfromrxfifo(&FIFOByte2);
			if ((FIFOByte1 == 'E') && (FIFOByte2 == 0x0D))
			{
				Got_Big_E = 0x01;
			}
			else