debug.c

MST720-DEMO程序

/******************************************************************************
 Copyright (c) 2005 MStar Semiconductor, Inc.
 All rights reserved.

 [Module Name]: Debug.c
 [Date]:	12-Jan-2005
 [Comment]:
   RS232 Debug Message Functions.
 [Reversion History]:
*******************************************************************************/

#define _DEBUG_C_
/********************
* INCLUDE FILES     *
*********************/
//#include <intrins.h>
#include "Project.h"
#include "TypeDef.h"
#include "Mcu_reg.h"
#include "Mcu.h"
#include "Ms_RWreg.h"
#include "Global.h"
#include "Debug.h"
#include "I2C.h"
#include "Ms_Func.h"
#include "Ms7X_reg.h"

#if RS232DBG
/********************
* STATIC DATA	    *
*********************/
#if USEXDATABUFF
XDATA BYTE g_ucUartBuffer[SIZE232];
XDATA WORD g_uwUartTxPtr, g_uwUartWritePtr;
XDATA BYTE g_ucUartRxFlag = 0;
XDATA BYTE g_ucUartTxFlag = 0;
XDATA BYTE g_ucRcvCmd[RCV_232_CMDW_LEN];
XDATA WORD g_uwRcvIndex = 0;
XDATA BYTE g_ucRV232cmdFlag = 0;
BYTE code tChangeLine[3] = "\x0d\x0a";
#else
WORD g_uwUartTxPtr, g_uwUartWritePtr;
BYTE g_ucUartRxFlag = 0;
BYTE g_ucUartTxFlag = 0;
BYTE g_ucRcvCmd[RCV_232_CMDW_LEN];
WORD g_uwRcvIndex = 0;
BYTE g_ucRV232cmdFlag = 0;
BYTE code tChangeLine[3] = "\x0d\x0a";
#endif	//USEXDATABUFF

/**********************
* FUNCTION PROTOTYPES *
***********************/
#if !USEXDATABUFF
void sysWriteUartOneByte(BYTE dat)
{
	BYTE ucTemp;
	
	ucTemp=IE;
	EA=0;
	TI=0;
	SBUF=dat;
	while(TI==0);
	TI=0;
	IE=ucTemp;
}

void sysWriteUartOneWord(WORD dat)
{
	BYTE ucTemp;
  
	ucTemp=IE;
	EA=0;
	TI=0;
	SBUF=HI_BYTE(dat);
	while(TI==0);
	TI=0;
	SBUF=LO_BYTE(dat);
	while(TI==0);
	TI=0;
	IE=ucTemp;
}

#else   //USEXDATABUFF
unsigned int sysCheckUartBuffer(void)
{
	if (((g_uwUartWritePtr+1)%SIZE232)==g_uwUartTxPtr)
		return FULL232;
	
	if (g_uwUartTxPtr==g_uwUartWritePtr) 
		return EMPTY232;               //buffer empty
		
	if (g_uwUartWritePtr>g_uwUartTxPtr)
 		return(SIZE232-(g_uwUartWritePtr-g_uwUartTxPtr)-1);
	
	if (g_uwUartWritePtr<g_uwUartTxPtr)
		return(g_uwUartTxPtr-g_uwUartWritePtr-1);
}

void sysWriteUartOneByte(BYTE dat)
{
	if (sysCheckUartBuffer()<=1) return;  //Full
	
	g_ucUartBuffer[g_uwUartWritePtr]=dat;
	g_uwUartWritePtr=(g_uwUartWritePtr+1)%SIZE232;
	
	if (g_ucUartTxFlag==0)
	{
		sysTxUartOneByte();   //triger transfer
	}
}

void sysWriteUartOneWord(WORD dat)
{
	if(sysCheckUartBuffer()<=2) 
		return;  //Full
	
	g_ucUartBuffer[g_uwUartWritePtr]=HI_BYTE(dat);
	g_uwUartWritePtr=(g_uwUartWritePtr+1)%SIZE232;
	g_ucUartBuffer[g_uwUartWritePtr]=LO_BYTE(dat);
	g_uwUartWritePtr=(g_uwUartWritePtr+1)%SIZE232;
	
	if (g_ucUartTxFlag==0)
	{
		sysTxUartOneByte();   //triger transfer
	}
}

void sysTxUartOneByte(void)
{
	BYTE ucDat;
  
	TI=0;
	g_ucUartTxFlag=0;
	
	if (sysCheckUartBuffer()==EMPTY232) 
		return;  //buffer empty
	
	ucDat=g_ucUartBuffer[g_uwUartTxPtr];
	g_uwUartTxPtr=(g_uwUartTxPtr+1)%SIZE232;
	SBUF=ucDat;
	g_ucUartTxFlag=1;
}
#endif  //USEXDATABUFF
//-----------------------------------------------------------------------------------

/*void Release_232(void)
{
	g_ucUartRxFlag=0;
}*/

void sysWriteString(BYTE *str)
{
	while(*str!='\0')
	{
		sysWriteUartOneByte(*str);
		str++;
	}
}

void sysWriteHex(BYTE dt,bit h)
{
	BYTE ucDat;
  
	ucDat=dt;
	
	if ((ucDat&0xf0)>=0xa0)	// convert high nibble
	{
		ucDat>>=4;
		ucDat+=55;
	}
	else
	{
		ucDat>>=4;
		ucDat+=0x30;
	}
	
	sysWriteUartOneByte(ucDat);

	ucDat=dt&0x0f;
	
	if (ucDat>=0x0a)		// convert low nibble
	{
		ucDat+=55;
	}
	else
	{
		ucDat+=0x30;
	}
	sysWriteUartOneByte(ucDat);
	
	if(h)  
		sysWriteUartOneByte('h');
}

void sysWriteUartHex4(WORD dt, bit h)
{
	BYTE ucDat;
	BYTE i;
  
	for (i=4; i>0; i--)
	{
		ucDat=(unsigned char)(dt>>((i-1)*4));
		ucDat=ucDat&0x0f;
		
		if (ucDat>=0x0a)
		{   //convert low nibble
			ucDat+=55;
		}
		else
		{
 			ucDat+=0x30;
		}
		
		sysWriteUartOneByte(ucDat);
	}
  
	if(h) 
		sysWriteUartOneByte('h');
}

void sysWriteDec(WORD dt)
{
	BYTE ucDat;
	WORD  i;
	BYTE ucFz;
  
	ucFz=0;
	
	for (i=10000; i>0; i/=10)
	{
		ucDat=(unsigned char)(dt/i);
		
		if (ucFz==0)
		{
			if (ucDat!=0) ucFz=1;
		}
    
		if (ucFz)
		{
			dt=dt-ucDat*i;  
			if (ucDat>=0x0a)
			{   
				ucDat+=55;
 			}
	 		else
			{
				ucDat+=0x30;
	  		}
			
			sysWriteUartOneByte(ucDat);
		}
	}
  
 	if (ucFz==0) 
		sysWriteUartOneByte('0');
}

void sysWriteUartDec6(DWORD dt)
{
	BYTE ucDat;
	DWORD i;
	BYTE ucFz;
  
	ucFz=0;
	
	for (i=1000000000; i>0; i/=10)
	{
		ucDat=(unsigned char)(dt/i);
		
		if (ucFz==0)
		{
			if(ucDat!=0) 
				ucFz=1;
		}
		
		if (ucFz)
		{
			dt=dt-ucDat*i;  
			if(ucDat>=0x0a)
			{   
 				ucDat+=55;
			}
			else
			{
				ucDat+=0x30;
			}
			sysWriteUartOneByte(ucDat);
		}
	}
  
	if (ucFz==0) 
		sysWriteUartOneByte('0');
}


#if (RS232DBG&MSG_CMDRECEIVE)

void sysRxUartOneByte(void)
{
	BYTE ucDat;
  
	RI=0;
	ucDat=SBUF;

	g_ucRcvCmd[g_uwRcvIndex]=ucDat;
	g_uwRcvIndex++;

	switch (g_ucRcvCmd[0])
	{
    		case 'E' :
		case 'R' :
		case 'X' :
		case 'K' :
		case 'D' :
			if (g_uwRcvIndex==RCV_232_CMD_L2)
			{
				g_uwRcvIndex=0;
				g_ucRV232cmdFlag=1;
			}
			break;
	
		case 'W' :
		case 'x' :
		case 'd' :
			if (g_uwRcvIndex==RCV_232_CMD_L3)
			{
				g_uwRcvIndex=0;
				g_ucRV232cmdFlag=1;
			}
			break;


		case 0x53:
			if (g_uwRcvIndex==RCV_232_CMD_L5)
			{
				g_uwRcvIndex=0;
				g_ucRV232cmdFlag=1;
			}
			break;

		default:
			g_uwRcvIndex=0;
	}
  
}

void sysRxCmdProcess(void)
{
	BYTE ucAddress;
	BYTE ucRegData;
	
	switch(g_ucRcvCmd[0])
	{
		case 0x53:
			// link password
			if ((g_ucRcvCmd[1]==0x45)&&(g_ucRcvCmd[2]==0x52)&&
				(g_ucRcvCmd[3]==0x44)&&(g_ucRcvCmd[4]==0x42))
			{
				sysWriteUartOneByte(0xb2);
				g_bDebugMode=1;
			}
			// exit link password
			if ((g_ucRcvCmd[1]==0x44)&&(g_ucRcvCmd[2]==0x45)&&
				(g_ucRcvCmd[3]==0x46)&&(g_ucRcvCmd[4]==0x47))
			{
				sysWriteUartOneByte(0x45);
				g_bDebugMode=0;
			}
			if ((g_ucRcvCmd[1]==0x44)&&(g_ucRcvCmd[2]==0x45)&&
				(g_ucRcvCmd[3]==0x47)&&(g_ucRcvCmd[4]==0x46))
			{
				sysWriteUartOneByte(0x45);
				Display.ucVCOMdc=mstReadByte(BK1_43_BVOM_DC);
  				Display.ucVCOMac=mstReadByte(BK1_44_BVOM_OUT);
				mstSaveDisplayData();
			}
			break;	
		//-------------------------------------------------------------
		//		Echo command
		//-------------------------------------------------------------
		case 'E':
			sysWriteUartOneByte(g_ucRcvCmd[1]);
			break;
		//-------------------------------------------------------------
		//		Read/Write
		//-------------------------------------------------------------
		case 'W':
		case 'x':
			//Write Register Command
			ucAddress = g_ucRcvCmd[1];
			ucRegData = g_ucRcvCmd[2];
			mstWriteByte(ucAddress, ucRegData);
			break;
			
		case 'R':
		case 'X':
			//Read Register Command
			ucAddress = g_ucRcvCmd[1];
			ucRegData = mstReadByte(ucAddress);
			sysWriteUartOneByte(ucRegData);
			break;
				
		//-------------------------------------------------------------
		//		ask peripheral
		//-------------------------------------------------------------
		//-------- tell diag.exe what peripheral is ...
		case 'K':
			//CPU_ColorBar(100,10);
			ucAddress = g_ucRcvCmd[1];
			switch (ucAddress)
			{
				case 'P':

					break;
				default:
					ucRegData = 'X';
					break;
			}
			sysWriteUartOneByte(ucRegData);
			break;


#if I2C_ENABLE

		//-------------------------------------------------------------
		//		EEPROM	  Read/Write
		//-------------------------------------------------------------
		case 'd':
			//-------- write EEPROM register -------
			ucAddress = g_ucRcvCmd[1];
			ucRegData = g_ucRcvCmd[2];
			sysI2CWriteByte(EEPROMID, ucAddress, ucRegData);
			break;

		case 'D':
			 //-------- read  EEPROM register -------
			ucAddress = g_ucRcvCmd[1];
			ucRegData = sysI2CReadByte(EEPROMID, ucAddress);
			sysWriteUartOneByte(ucRegData);
			break;

#endif	// I2C_ENABLE
	} // Switch
}

void sysCheckUartCmd(void)
{
	do
	{
		if(g_ucUartRxFlag)
		{
			if(g_ucRV232cmdFlag)
			{
				g_ucRV232cmdFlag=0;
				sysRxCmdProcess();
			}
		}
	}while(g_bDebugMode);
}

#endif  //(RS232DBG&MSG_CMDRECEIVE)

#if 0
void sysUartIntrrupt(void) interrupt 4
{
	if(g_ucUartRxFlag)
	{
		if(TI)
		{
			TI=0;
#if USEXDATABUFF
		sysTxUartOneByte();
#endif 
		}

		if(RI)
		{
			RI=0;
#if (RS232DBG&MSG_CMDRECEIVE)
	sysRxUartOneByte();
#endif
		}
	}
	else
	{
		TI=RI=0;
	}
}
#endif	

void sysUartDebugInit(void)
{

	SCON = 0x50;			// mode 1, 8-bit UART, enable receive

	if (_SMOD) 
		PCON |= 0x80;

	TMOD = (TMOD & 0x0f) | 0x20;	// timer1, mode 2, 8-bit reload
	TH1 = TIMER1_MODE2_TH1; 	// set timer1(buad rate)
	TR1 = 1;				// timer1 run

	TI = 0; 				// clear transmit flag
	RI = 0; 				// clear received flag
	PS = 0; 				// set uart priority low
	ES = 1; 				// enable uart interrupt
	
	g_bDebugMode=0;
	g_uwUartTxPtr=g_uwUartWritePtr=0;
	g_ucUartRxFlag=1;

}
void printf(BYTE code *pFmt, WORD wVal)
{
    BYTE ucBff, ucDisp;
    BOOL bNotZero=FALSE, bHex=FALSE;
    WORD wDivider=10000;

    while( ucBff = *(pFmt++) )
    {
        if(ucBff == '%') // check special case
        {
            switch( *(pFmt++) ) // check next character
            {
                case 'x': // hexadecimal number
                case 'X':
                    wDivider = 0x1000;
                    bHex = TRUE;
                case 'd': // decimal number
                case 'i':
                    if(wVal)
                    {
                        while(wDivider)
                      	{
                      	    ucDisp = wVal/wDivider;
                            wVal -= ucDisp*wDivider;
                            if(ucDisp)
                          	    bNotZero=TRUE;

                            if(bNotZero)
                          	{
                          	    if (ucDisp>9)
                                    sysWriteUartOneByte(ucDisp+55);
                                else
                                    sysWriteUartOneByte(ucDisp+0x30);
                            }

                            if(bHex)
                          	    wDivider /= 0x10;
                            else
                          	    wDivider /= 10;
                        }
                    }
                    else
      	                sysWriteUartOneByte('0');
                    break;
            } // switch
        }
        else // general
            sysWriteUartOneByte(ucBff); // put a character
    } // while
}
#endif //RS232DBG **********************************************************************