st3lib10.c

SPWM三相波形发生器

		DEF_232_POWER=0;
		DEF_232_RXD	 =0;
		DEF_232_TXD  =0;
		DEF_MODEM_TXD=1;
		DEF_MODEM_RXD=0;
		DEF_MODEM_TXC=0;
		DEF_MODEM_RXC=0;
		if		(Ide_AREA(PUB_HIGH_AddrICNo,0)) PUB_Free=0;
		DEF_232_POWER=1;
		DEF_232_RXD	 =1;
		DEF_232_TXD  =1;
		DEF_MODEM_RXD=1;
		DEF_MODEM_TXC=1;
		DEF_MODEM_RXC=1;
}

uchar	Read_at24c(uint offset, uint count, uchar *buff)
{
	return Read_at24(offset, count, buff);
}

uchar	Write_at24c(uint offset, uint count, uchar *buff)
{
	if ( Write_at24(offset, count, buff) )
		return 1;
	else 
	{
		if ( Read_at24(offset, count, PixelBuff) )
			return 2;
		else
		{
			if ( memcmp(buff, PixelBuff, count) )
				return 3;
			else 
				return 0;
		}
	}
}

uchar	_SysDataRead( uint offset, uint count, uchar *buff)
{
	return Read_at24c(offset, count, buff);
}

uchar	_SysDataWrite(uint offset, uint count, uchar *buff)
{
	return Write_at24c(offset, count, buff);
}

///////////////////////////////////////////////////XMem R/W functions
uchar  _XMemPage(void)
{
    return PUB_XMEM_Page[0];
}

uchar	_DataBackup(uchar Block, Sector, uchar *dataBuf)
{
	uint  Times;
	uchar k, j;

	Times = 60000;
	_OutHighAddr(0x10);
	_SelAddrRam();
	XBYTE[0xD555] = 0xAA;
	XBYTE[0xAAAA] = 0x55;
	XBYTE[0xD555] = 0xA0;
	_OutHighAddr(Block);
	j = 0;
	while ( 1 )
	{
		k = dataBuf[j];
		XBYTE[Sector*256 + j + 0x8000] = k;
		j++;
		if ( j == 0 )
			break;
	}
	while ( Times )
	{
		j = XBYTE[Sector*256 + 0x80FF];
		if ( j == k )
			break;
		Times--;
	}
	if ( j != k )
		k = 0;
	else
	{
		j = 0;
		while ( 1 )
		{
			k = XBYTE[Sector*256 + j + 0x8000];
			if ( k != dataBuf[j] )
			{
				k = 0;
				break;
			}
			j++;
			if ( j == 0 )
			{
				k = 1;
				break;
			}
		}
	}
	_OutHighAddr( PUB_HIGH_Addr );
	return k;
}

uchar	_DataRestore(uchar Block, Sector, uchar *dataBuf)
{
	uint  Times, i;
	uchar k, j;

	_OutHighAddr(Block);
	_SelAddrRam();
	for (i=0; i<256; i++)
	{
		dataBuf[i] = XBYTE[Sector*256 + i + 0x8000];
	}
	_OutHighAddr( PUB_HIGH_Addr );
	return 1;
}

void   _MemToXMem(uint DataLen,uchar XMemPage,uint XMemOffset,uchar* MemBuff)
{
    uint i;

	_OutHighAddr(PUB_XMEM_Page[XMemPage+1]);
	_SelAddrRam();
	XMemOffset = ( XMemOffset  ) | 0x8000;
	if(DataLen&0x8000) DataLen=0x8000;
	for(i=0; i<DataLen; i++) 
		XBYTE[XMemOffset + i] = *(MemBuff+i);
	_OutHighAddr( PUB_HIGH_Addr );
    return;
}

void   _XMemToMem(uint DataLen,uchar* MemBuff, uchar XMemPage,uint XMemOffset)
{
    uint i;

    _OutHighAddr(PUB_XMEM_Page[XMemPage+1]);
	_SelAddrRam();
    XMemOffset = ( XMemOffset  ) | 0x8000;
	if(DataLen&0x8000) DataLen=0x8000;
    for(i=0; i<DataLen; i++) 
		*(MemBuff+i) = XBYTE[XMemOffset + i ];
	_OutHighAddr( PUB_HIGH_Addr );
    return ;
}

void	_InitXMEM(void)
{
	uchar i, j;

	_OutHighAddr(0x15);
	_SelAddrRam();
    j = 0;
    i = _GetCBYTE(DEF_RAM_PAGE);
    if ( (i & 0x0F) == 0x03 )
    {
        for(i=13; i<16; i++)
		{
            j++;
            PUB_XMEM_Page[j] = i;
		}
    }
    else if ( (i & 0x0F) == 0x0F )
    {
        for(i=0; i<16; i++)
		{
            if (i != 4)
            {
                j++;
                PUB_XMEM_Page[j] = i;
            }
		}
    }
    PUB_XMEM_Page[0] = j;
	_OutHighAddr( PUB_HIGH_Addr );
	return;
}

////////////////////////////////////////////////////Display functions
void	_SetBkLight(uchar Level)
{
	if(Level)
	   PUB_HIGH_Card = PUB_HIGH_Card | 0x08;
	else
	   PUB_HIGH_Card = (PUB_HIGH_Card & (~0x08));
	_SelAddrMain();
	XBYTE[DEF_HIGH_Card] = PUB_HIGH_Card;
	return;
}

void	_SetContrast(uchar Level)
{
	uchar i;
	
	i = Level & 0x3f;
	_SelAddrMain();
	XBYTE[DEF_ADDR_LCDCOMM] = 0x81;  // SET REFERENCE VOLTAGE MODE
	XBYTE[DEF_ADDR_LCDCOMM] = i;     // SET REFERENCE VOLTAGE REGISTER
	return;
}

void	_InitLCD(void)
{
	_SelAddrMain();
	XBYTE[DEF_ADDR_LCDCOMM] = 0xc8;  // SET SHL
	XBYTE[DEF_ADDR_LCDCOMM] = 0xa3;  // SET LCD BIAS
	XBYTE[DEF_ADDR_LCDCOMM] = 0x81;  // SET REFERENCE VOLTAGE MODE
	XBYTE[DEF_ADDR_LCDCOMM] = 0x18;  // SET REFERENCE VOLTAGE REGISTER
	XBYTE[DEF_ADDR_LCDCOMM] = 0x26;  // REGULATOR RESISTOR SELECT
	XBYTE[DEF_ADDR_LCDCOMM] = 0x2f;  // POWER CONTROL
	_Delay(5);
	XBYTE[DEF_ADDR_LCDCOMM] = 0xaf;  // DISPLAY ON
	_ClearScreen();
	return;
}

void	_ClearScreen(void)
{
	uchar i,j;
	
	_SelAddrMain();
	for(i=0;i<8;i++)
	{
		XBYTE[DEF_ADDR_LCDCOMM] = 0xb0 + i;
		XBYTE[DEF_ADDR_LCDCOMM] = 0x10;
		XBYTE[DEF_ADDR_LCDCOMM] = 0x00;
		for(j=0;j<132;j++)
			XBYTE[DEF_ADDR_LCDDATA] = 0x00;
	}
	return;
}

void    _SetRevDisp(uchar Level)
{
	_SelAddrMain();
	if(Level)
	   XBYTE[DEF_ADDR_LCDCOMM] = 0xa7;
	else
	   XBYTE[DEF_ADDR_LCDCOMM] = 0xa6;
	return;
}

void    _SetEntDisp(uchar Level)
{
	_SelAddrMain();
	if(Level)
	   XBYTE[DEF_ADDR_LCDCOMM] = 0xa5;
	else
	   XBYTE[DEF_ADDR_LCDCOMM] = 0xa4;
	return;
}

uchar	_DispXY01( uchar LINE, uchar COLUM, uchar Level, uchar *DispStr)
{
	uchar QM,WM,k;
	uchar page,col;
	uint  i,j;
	
	if((LINE > 4) || (COLUM > 16)) return 1;
	
	i = 0;
	memset(PixelBuff,0,sizeof(PixelBuff));
	while ( (i<16) && ( DispStr[i] > 0 ))
	{
          QM = DispStr[i];
          if ( QM <= 0x80 )
	  	_Pixel2(QM,0,(PixelBuff +(int)i*8),(PixelBuff+(int)i*8)+128);
          else
          {
             if ( i > 15 )
                 break;
             WM = DispStr[i+1];
             _Pixel2(QM,WM,PixelBuff+(int)i*8,(PixelBuff +(int)i*8)+128);
             i++;
          }
          i++;
	}
	
	k = strlen(DispStr);
	k = 8 * k;
	if( Level & 0x02 )
		for(i=0;i<k;i++)
			PixelBuff[i+128] = PixelBuff[i+128] | 0x80;
	if( Level & 0x01 )
		for(i=0;i<k;i++)
		{
			PixelBuff[i] = PixelBuff[i] ^ 0xff;
			PixelBuff[i+128] = PixelBuff[i+128] ^ 0xff;
		}
	
	page = 2 * (LINE - 1);
	col  = 8 * (COLUM - 1) + 2;
	_SelAddrMain();
	XBYTE[DEF_ADDR_LCDCOMM] = 0xb0 + page;
	XBYTE[DEF_ADDR_LCDCOMM] = 0x00 + (col&0x0f);
	XBYTE[DEF_ADDR_LCDCOMM] = 0x10 + ((col>>4)&0x0f);
	
	i = 0;
	j = col;
	while( (j<130)&&(i<k) )
	{
		XBYTE[DEF_ADDR_LCDDATA] = PixelBuff[i];
		i++;
		j++;
	}
	page = page + 1;
	XBYTE[DEF_ADDR_LCDCOMM] = 0xb0 + page;
	XBYTE[DEF_ADDR_LCDCOMM] = 0x00 + (col&0x0f);
	XBYTE[DEF_ADDR_LCDCOMM] = 0x10 + ((col>>4)&0x0f);
	i = 0;
	j = col;
	while( (j<130)&&(i<k) )
	{
		XBYTE[DEF_ADDR_LCDDATA] = PixelBuff[i+128];
		i++;
		j++;
	}
	return 0;
}

uchar	_DispXY( uchar LINE, uchar COLUM, uchar Level, uchar *DispStr)
{
	uchar i;
	uchar Temp[DEF_LCD_COL+1];

	i = strlen(DispStr);
	if ( i > DEF_LCD_COL )
		i = DEF_LCD_COL;
	memset(Temp, 0, DEF_LCD_COL+1);
	memcpy(Temp, DispStr, i);
	return _DispXY01(LINE, COLUM, Level, Temp);
}

void	_Display(uchar ucNoLine, uchar *pzText)
{
	uchar i;
	uchar Temp[DEF_LCD_COL+1];

	memset(Temp, 0, DEF_LCD_COL+1);
	i = strlen(pzText);
	if ( i > DEF_LCD_COL )
		i = DEF_LCD_COL;
	memcpy(Temp, pzText, i);
	memset(Temp+i, 0x20, DEF_LCD_COL-i);
	_DispXY01(ucNoLine, 1, 0x00, Temp);
	return;
}

uchar	_DispTXT(uchar LINE, uchar COLUM, uchar *DispStr)
{
	return 1;
}

uchar	_CopyImage(uchar SCREEN_X, SCREEN_Y, BUFLEN_X, BUFLEN_Y, uchar *DataBuff)
{
	return 1;
}


uchar   _Print(uchar Level,uchar *Text)
{
	uchar i;
	uchar Temp[48+1];

//	_SelAddrMain();
	i = strlen(Text);
	if ( i > 48 )
		i = 48;
	memset(Temp+i, 0, 1);
	memcpy(Temp, Text, i);
	return _Printer(Level, Temp);
}
//////////////////////////////////////////Keyboard opration functions
uchar _KeyBoardUnite(uchar kVal)
{
	uchar kk;

	switch ( kVal )
	{
		case DEF_KEY_0:		kk = 0x30; break;
		case DEF_KEY_1:		kk = 0x31; break;
		case DEF_KEY_2:		kk = 0x32; break;
		case DEF_KEY_3:		kk = 0x33; break;
		case DEF_KEY_4:		kk = 0x34; break;
		case DEF_KEY_5:		kk = 0x35; break;
		case DEF_KEY_6:		kk = 0x36; break;
		case DEF_KEY_7:		kk = 0x37; break;
		case DEF_KEY_8:		kk = 0x38; break;
		case DEF_KEY_9:		kk = 0x39; break;
		case DEF_KEY_ESC:	kk = 0x1B; break;
		case DEF_KEY_ENTER: kk = 0x0D; break;
		case DEF_KEY_CLEAR:	kk = 0x08; break;
		case DEF_KEY_DOT:	kk = 0x2E; break;
		default:			kk = 0xFF; break;
	}
	return kk;
}

uchar _KeyBoardGet(void)
{
    uchar k;

	PUB_Random++;
    while ( PUB_Key == 0 ) 
		_KeyBoardTest();
    k = PUB_Key;
    PUB_Key  = 0;
    return _KeyBoardUnite( k );
}

uchar _KeyBoardTest(void)
{
    uchar i, j, k, Row, Col;
	uchar e, p;

//	Ide_AREA(PUB_HIGH_AddrICNo,1);//lxj
	_SelAddrMain();
	k = 0;
	XBYTE[DEF_HIGH_Date] =  PUB_HIGH_Date & 0x0F;
	if ( ( XBYTE[DEF_HIGH_Key] & 0x0F) == 0x0F )
		PUB_Free = 0;
	else
	{
		j = 0x10;
		Row = Col = 0;
		for (i=0; i<4; i++)
		{
			XBYTE[DEF_HIGH_Date] = ((PUB_HIGH_Date | 0xF0) ^ j);
			k =  XBYTE[DEF_HIGH_Key] & 0x0F;
			if ( k != 0x0F )
			{
				_Delay(20);
				k =  XBYTE[DEF_HIGH_Key] & 0x0F;
				switch( k )
				{
					case 0x0E: Col=1; break;
					case 0x0D: Col=2; break;
					case 0x0B: Col=3; break;
					case 0x07: Col=4; break;
					default  : Col=0; break;
				}
				if (Col != 0)
				{
					Row = i;
					break;
				}
			}
			j = j << 1;
		}
		if ( Col )
		{
			Col--;
			k = Row * 4 + Col;
			if (Col == 0)
				k = k + 4;
			if ( PUB_Free == k )
				k = 0;
			else
			{
				PUB_Key  = k;
				PUB_Free = k;
			}
		}
		else
			k = 0;
	}

	XBYTE[DEF_HIGH_Date] = PUB_HIGH_Date;
	return k;
}

////////////////////////////////////IC Card Socket opration functions
uchar	_TestLock(void)
{
	return  0;
}

uchar	_TestFront(void)
{
	return  0;
}

uchar	_SetLock(uchar Level)
{
	return 1;
}

///////////////////////////////////////IC/SAM Card opration functions
void   _CardSetPower(uchar Level)
{
    uchar cc;

    cc = 1;
    if( PUB_Card_ICNO > 1)
         return;
    if (  PUB_Card_ICNO > 0 ) 
		cc = cc << PUB_Card_ICNO;
    _SelAddrMain();
    if ( Level == 0 )
		PUB_HIGH_Card = PUB_HIGH_Card & (~cc);
    else  
		PUB_HIGH_Card = PUB_HIGH_Card | cc;
    XBYTE[DEF_HIGH_Card] = PUB_HIGH_Card;
    return;
}

void   _CardSetCard(uchar ICNO)
{
    uchar i;
    
    i = ICNO;
    if( ICNO==0 ) i = 1;
    if( ICNO==1 ) i = 0;
    PUB_Card_ICNO = i;
    _SelAddrMain();
    PUB_HIGH_AddrICNo = (PUB_HIGH_AddrICNo & 0x1F) | ((i<<5) & 0xE0);
    XBYTE[DEF_HIGH_AddrICNo] = PUB_HIGH_AddrICNo;
    return;
}

void   _MemCardEn(uchar Level)
{
	uchar cc;
	
	switch(PUB_Card_ICNO)
	{
		case 0:   cc = 0x10; break;
    		case 1:   cc = 0x20; break;
    		default:  cc = 0x00;
  	}
  	if(Level) PUB_HIGH_Card_Rest = (PUB_HIGH_Card_Rest | cc);
  	else  PUB_HIGH_Card_Rest = (PUB_HIGH_Card_Rest & (~cc));
  	_SelAddrMain();
  	XBYTE[DEF_HIGH_Card_Rest] = PUB_HIGH_Card_Rest;
  	return;
}

void   _CardSetPGM(uchar Level)
{
	uchar cc;
	
	switch(PUB_Card_ICNO)
	{
		case 0:   cc = 0x10; break;
    		case 1:   cc = 0x20; break;
    		default:  cc = 0x00;
  	}
  	if(Level) PUB_PrintOutData = (PUB_PrintOutData | cc);
  	else  PUB_PrintOutData = (PUB_PrintOutData & (~cc));
  	_SelAddrMain();
  	XBYTE[DEF_PRINT_OUTDATA] = PUB_PrintOutData;
  	return;
}

void   _CardSetFUS(uchar Level)
{
	uchar cc;
	
	switch(PUB_Card_ICNO)
	{
		case 0:   cc = 0x40; break;
    		case 1:   cc = 0x80; break;
    		default:  cc = 0x00;
  	}
  	if(Level) PUB_PrintOutData = (PUB_PrintOutData | cc);
  	else  PUB_PrintOutData = (PUB_PrintOutData & (~cc));
  	_SelAddrMain();
  	XBYTE[DEF_PRINT_OUTDATA] = PUB_PrintOutData;
  	return;
}

void   _CardSetReset(uchar Level)
{
	uchar cc;

	cc = 1;
	if (PUB_Card_ICNO !=0)
		cc = cc << (PUB_Card_ICNO & 0x03);