st3lib10.c

SPWM三相波形发生器

		if (EXP_CountTT >= EXP_COMMBUFF_LEN-1)	EXP_CountTT = 0;
		if ( EXP_CountTH != EXP_CountTT )
		{
			EXP_ByteTT = EXP_CommBuffT[EXP_CountTT];
			XBYTE[EXP_THR] = EXP_ByteTT;
		}
    }
		}
	P1_5 = R_P1_5;	P1_6 = R_P1_6;
}
*/
_IntTime2()		interrupt DEF_INT_TIME2
{
     	if(!(++PUB_Timer20))
     	  if (!(++PUB_Timer21))
     	     if(!(++PUB_Timer22)) ++PUB_Timer23;
	TF2 = 0x00;
}

//////////////////////////////////////////////////////Time2 functions
void	_ClearTickCount(void)
{
	ET2 = 0;
	PUB_Timer20 = 0;
	PUB_Timer21 = 0;
	PUB_Timer22 = 0;
	PUB_Timer23 = 0;
	ET2 = 1;
	return;
}

ulong	_GetTickCount(void)
{
	ulong i;

	ET2=0;
	i = PUB_Timer23;
	i = i << 8;
	i = i | PUB_Timer22;
	i = i << 8;
	i = i | PUB_Timer21;
	i = i << 8;
	i = i | PUB_Timer20;
	ET2=1;
	return i; 
}

void   _InitTimer(void)
{
    IT1 = 0x01;
    IE1 = 0x00;
    TMOD = 0x22;
    TH0 = 132;
    TL0 = TH0;
    TR0 = 0x00;
    TR1 = 0x00;
    IT0 = 0x01;
	TR2  = 0;
	ET2  = 0;
	RCAP2L = 0x00;
	RCAP2H = 0xDC;
	C_T2 = T2IE = T2RSE = CP_RL2 = 0;
	T2IP = BGEN = 0;
	PUB_Timer20 = 0;
	PUB_Timer21 = 0;
	PUB_Timer22 = 0;
	PUB_Timer23 = 0;
	ET2  = 1;
	TR2  = 1;
	return;
}

//////////////////////////////////////////////////Clock R/W functions
#define   DEF_DATEIN_L      0xFE
#define   DEF_DATEIN_H      0x01
#define   DEF_DATEWR_L      0xFD
#define   DEF_DATEWR_H      0x02
#define   DEF_DATECS_L      0xFB
#define   DEF_DATECS_H      0x04
#define   DEF_DATECLK_L     0xF7
#define   DEF_DATECLK_H     0x08


uchar  _ClockByteInc(uchar DB)
{
	uchar i;
	uchar cci, cco;

	cco = DB;
	cci = 0;
	for (i=0;i<8;i++)
	{
		if ( cco & 0x01)
		{
			PUB_HIGH_Date = PUB_HIGH_Date | DEF_DATEIN_H;
			XBYTE[DEF_HIGH_Date] = PUB_HIGH_Date;
		}
		else
		{
			PUB_HIGH_Date = PUB_HIGH_Date & DEF_DATEIN_L;
			XBYTE[DEF_HIGH_Date] = PUB_HIGH_Date;
		}
		cco = cco >> 1;
		cci = cci >> 1;
		PUB_HIGH_Date = PUB_HIGH_Date & DEF_DATECLK_L;
		XBYTE[DEF_HIGH_Date] = PUB_HIGH_Date;
		PUB_HIGH_Date = PUB_HIGH_Date | DEF_DATECLK_H;
		XBYTE[DEF_HIGH_Date] = PUB_HIGH_Date;

		if ( ( XBYTE[DEF_HIGH_Key] & 0x80) != 0x00 )
			cci = cci | 0x80;
	}
	return cci>>4;
}

void   _ClockSet(stClock* ptDateTime)
{
	uchar i,j,k;
	uchar OutData[13];

	for(i=0;i<13;i++)
	{
         switch (i)
         {
           case 2 :k = ( *ptDateTime).minute % 10;      break;
           case 3 :k = ( *ptDateTime).minute / 10;      break;
           case 4 :k = ( *ptDateTime).hour;             break;
           case 6 :k = ( *ptDateTime).weekday% 7;       break;
           case 7 :k = ((*ptDateTime).day    - 1 )% 10; break;
           case 8 :k = ((*ptDateTime).day    - 1 )/ 10; break;
           case 9 :k = ((*ptDateTime).month  - 1) % 10; break;
           case 10:k = ((*ptDateTime).month  - 1) / 10; break;
           case 11:k = ( *ptDateTime).year   % 10;      break;
           case 12:k = ( *ptDateTime).year   / 10;      break;
         }
         OutData[i] = k;
	}
    _SelAddrMain();
	PUB_HIGH_Date = PUB_HIGH_Date & DEF_DATEWR_L;
	XBYTE[DEF_HIGH_Date] = PUB_HIGH_Date;
	DEF_PORT_DATECS = 0;
	_ClockByteInc(0x8f);
	DEF_PORT_DATECS = 1;
	DEF_PORT_DATECS = 0;
	DEF_PORT_DATECS = 1;
	PUB_HIGH_Date = PUB_HIGH_Date | DEF_DATEWR_H;
	XBYTE[DEF_HIGH_Date] = PUB_HIGH_Date;
	DEF_PORT_DATECS = 0;
	k = 0x8;
    _ClockByteInc(0x0e);
    while ( (k & 0x8) != 0 )
	{
		k = _ClockByteInc(0x0E);
	}
	DEF_PORT_DATECS = 1;
	PUB_HIGH_Date = PUB_HIGH_Date & DEF_DATEWR_L;
	XBYTE[DEF_HIGH_Date] = PUB_HIGH_Date;
	DEF_PORT_DATECS = 0;
	for (i=12; i>1; i--)
    {
		if (i != 5)
			for (j=0;j<OutData[i];j++)
				_ClockByteInc(i);
			else
				_ClockByteInc(0x1d);
    }
    _ClockByteInc(0x5d);
	DEF_PORT_DATECS = 1;
	return;
} 

void   _ClockRead(stClock* ptDateTime)
{
	uchar i,k;
	uchar InData[16];

    _SelAddrMain();
	PUB_HIGH_Date = PUB_HIGH_Date | DEF_DATEWR_H;
	XBYTE[DEF_HIGH_Date] = PUB_HIGH_Date;
	DEF_PORT_DATECS = 0;
	k = 0x8;
    _ClockByteInc(0x0e);
    while ( (k & 0x8) != 0 )
    {
         k = _ClockByteInc(0x0E);
    }
    _ClockByteInc(0x00);
    for (i=1;i<16;i++)
    {
         InData[i-1] = _ClockByteInc(i);
    }
    InData[15] = _ClockByteInc(0x00);
	DEF_PORT_DATECS = 1;
	(*ptDateTime).second  = InData[0]  + InData[1]  * 10;
    (*ptDateTime).minute  = InData[2]  + InData[3]  * 10;
    (*ptDateTime).hour    = InData[4]  + (InData[5] & 0x07) * 10;
    (*ptDateTime).weekday = InData[6];
    (*ptDateTime).day     = InData[7]  + InData[8]  * 10;
    (*ptDateTime).month   = InData[9]  + InData[10] * 10;
    (*ptDateTime).year    = InData[11] + InData[12] * 10;
    return;
}

//////////////////////////////////////////////Communication functions
void   _AsyncOpen(uint Baud, uchar Parity)
{
	uchar THData;
    uchar cc;

    THData = 0xfd;
    switch ( Baud )
    {
		case 19200:  THData = 0xfd; break;
		case  9600:  THData = 0xfd; break;
		case  4800:  THData = 0xfa; break;
		case  2400:  THData = 0xf4; break;
		case  1200:  THData = 0xe8; break;
    }
	if (Baud==19200)
		PCON|= 0x80;
	else
		PCON&= 0x7f;
    PUB_CommParity = Parity;
    TR1  = 0x00;
    cc = TMOD;
    TMOD = (cc & 0x0f) | 0x20;
    if (Parity==0)
		SCON = 0x40;
    else 
		SCON = 0xc0;
    TR1  = 0x00;
    TH1  = THData;
    TL1  = TH1;
    REN  = 0x01;
    RI   = 0x00;
    TI   = 0x00;
    TR1  = 0x01;
    ES = 1;
    PUB_Async_RI = 0;
    PUB_Async_TI = 1;
	memset(PUB_CommBuffR, 0, DEF_COMMBUFF_LEN);
	memset(PUB_CommBuffT, 0, DEF_COMMBUFF_LEN);
	PUB_CountRH = PUB_CountRT = 0;
	PUB_CountTH = PUB_CountTT = 0;
    return;
}

void   _EXP_Open(uint Baud, uchar Parity)
{
//ff83bf82d08380804881008303840a82a1810302  FC  level 8
//ff83bf82c08380804881008303840a8201810302  FC  level 8
	EX1 = 0;
	_SelAddrModem();
	XBYTE[EXP_LCR] = 0xbf;
	XBYTE[EXP_EFR] = 0xd0;

	XBYTE[EXP_LCR] = 0x80;
    XBYTE[EXP_DLL] = (unsigned char) (EXP_XTAL/(16L*Baud));
    XBYTE[EXP_DLM] = (EXP_XTAL/(16L*Baud))>>8;

    EXP_CommParity = Parity;
    if (Parity==0)  
		XBYTE[EXP_LCR] = 0x03;
    else if (Parity==DEF_PARITY_ODD)  
		XBYTE[EXP_LCR] = 0x0b;
    else 
		XBYTE[EXP_LCR] = 0x1b;

	XBYTE[EXP_MCR] = 0x0a;
	XBYTE[EXP_FCR] = 0xa1;
//	XBYTE[EXP_FCR] = 0x07;
//	XBYTE[EXP_FCR] = 0x01;
	XBYTE[EXP_IER] = 0x03;
	while ( XBYTE[EXP_LSR]&0x01)
	{
		EXP_Async_RecData = XBYTE[EXP_RHR];
	}
	EXP_Async_RecData = XBYTE[EXP_ISR];
	IE1 = 0;
	EX1 = 1;
    EXP_Async_RI = 1;
    EXP_Async_TI = 1;

	EXP_CountRH = EXP_CountRT = 0;
	EXP_CountTH = EXP_CountTT = 0;
    return;
}

void _Dial_Tone(uchar tone_on)
{
		_SelAddrMain();
		if(tone_on)
			PUB_HIGH_Card_Rest = PUB_HIGH_Card_Rest | 0x40;
		else
			PUB_HIGH_Card_Rest = (PUB_HIGH_Card_Rest & (~0x40));
		XBYTE[DEF_HIGH_Card_Rest] = PUB_HIGH_Card_Rest;
}

uchar  _AsyncPutTest(void)
{
	return PUB_Async_TI;
}

uchar  _EXP_PutTest(void)
{
	return EXP_Async_TI;
}

void _AsyncPut(uchar ucValue)
{
	uchar Flag;

	if ( PUB_Async_TI == 0)
		return;
	ES = 0;
	Flag = 0;
	if (PUB_CountTH == PUB_CountTT)
		Flag = 1;
	PUB_CommBuffT[PUB_CountTH] = ucValue;
	PUB_CountTH++;
	if (PUB_CountTH >= DEF_COMMBUFF_LEN-1)	PUB_CountTH = 0;
	if (PUB_CountTH == PUB_CountTT)
		PUB_Async_TI = 0;

	if ( Flag )
	{
		ACC = ucValue;
		TB8 = P;
		if ( PUB_CommParity == DEF_PARITY_ODD ) 
			TB8 = TB8 ^ 0x01;
		SBUF = ucValue;
	}
	ES = 1;
    return;
}

void _EXP_Put(uchar ucValue)
{

	if ( EXP_Async_TI == 0)
		return;
	EX1 = 0;
	if (EXP_CountTH == EXP_CountTT)
	{
		_SelAddrModem();
		EXP_ByteTT = ucValue;
		XBYTE[EXP_THR] = EXP_ByteTT;
	}
	EXP_CommBuffT[EXP_CountTH] = ucValue;
	EXP_CountTH++;
	if (EXP_CountTH >= EXP_COMMBUFF_LEN-1)	EXP_CountTH = 0;
	if (EXP_CountTH == EXP_CountTT)
		EXP_Async_TI = 0;
	EX1 = 1;
    return;
}

uchar  _AsyncGetTest(void)
{
	if ( PUB_CountRH != PUB_CountRT )
		return 1;
	else
		return 0;
}

uchar  _EXP_GetTest(void)
{
	if ( EXP_CountRH != EXP_CountRT )
		return 1;
	else
		return 0;
}

uchar  _AsyncGet(void)
{
	uchar cc;

	while ( PUB_CountRH == PUB_CountRT );
	ES = 0;
	cc = PUB_CommBuffR[PUB_CountRT];
	PUB_CountRT++;
	if (PUB_CountRT >= DEF_COMMBUFF_LEN-1)	PUB_CountRT = 0;
	ES = 1;
	return cc;
}

uchar  _EXP_Get(void)
{
	uchar cc;

	while ( EXP_CountRH == EXP_CountRT );
	EX1 = 0;
	cc = EXP_CommBuffR[EXP_CountRT];
	EXP_CountRT++;
	if (EXP_CountRT >= EXP_COMMBUFF_LEN-1)	EXP_CountRT = 0;
	EX1 = 1;
	return cc;
}

void  _AsyncSetReceive(uchar Level)
{
    if ( Level==0 ) 
		REN = 0x00;
    else 
		REN = 0x01;
    return;
}

void  _AsyncClose(void)
{
	ES  = 0x00;
	TR1 = 0x00;
	RI  = 0x00;
	TI  = 0x00;
	return ;
}

void  _EXP_Close(void)
{
	EX1 = 0;
	EXP_CountRH = EXP_CountRT = 0;
	return ;
}

////////////////////////////////////////////////Public base functions
void  _ChipSelect(uchar cs)
{
	if (cs & 0x01)
	{	R_P1_5 = 1;	P1_5 = 1;}
	else
	{	R_P1_5 = 0;	P1_5 = 0;}
	if (cs & 0x02)
	{	R_P1_6 = 1;	P1_6 = 1;}
	else
	{	R_P1_6 = 0;	P1_6 = 0;}
    return;
}

void _OutHighAddr(uchar HA)
{
	PUB_HIGH_AddrICNo = (PUB_HIGH_AddrICNo & 0xE0) | (HA & 0x1F);
	_SelAddrMain();
	XBYTE[DEF_HIGH_AddrICNo] = PUB_HIGH_AddrICNo;
	_SelAddrRam();
	return;
}

void   _SelAddrMain(void)
{
    _ChipSelect(0x01);
}

void   _SelAddrModem(void)
{
    _ChipSelect(0x02);
}

void   _SelAddr040(void)
{
    _ChipSelect(0x03);
}

void   _SelAddrRam(void)
{
    _ChipSelect(0x00);
}

void	_Buzzer(void)
{
	uint  i, j;

	ET2 = 0;
	_SelAddrMain();
	for (i=0;i<300;i++)
	{
		PUB_HIGH_Card = PUB_HIGH_Card ^ 0x04;
		XBYTE[DEF_HIGH_Card] = PUB_HIGH_Card;
		for (j=0; j<100; j++);
	}
	ET2 = 1;
	return;
}

void	_Reset(void)
{
	SysReset();
	return;
}

void	_Delay(uint mSec)
{
	uchar j;

	while (mSec > 0 )
	{
		for(j=0; j<230; j++);
		mSec--;
	}
	return;
}

uchar	_Random(void)
{
	PUB_Random = ( PUB_Random ^ 55 ) * 59;
	return PUB_Random;
}

void	_SetLED(uchar Level)
{
	if (Level)
		P1_7 = 0x00;
	else
		P1_7 = 0x01;
	return;
}

uchar  _ReverseData(uchar SouData)
{
    uchar i,d;
    
    d = 0;
    for (i=0;i<8;i++)
    {
        d = d << 1;
        if ( (SouData & 0x01) == 0) d++;
        SouData = SouData >> 1;
    }
    return d;
}

void BCDtoChar(uchar *pBCD, uint BCDLen, uchar *pChar) 
{
   uchar usHexToChar[16]= "0123456789ABCDEF"; 
   uint i;

   for(i=0; i<BCDLen; i++)
   {
      pChar[2*i]   = usHexToChar[(pBCD[i] >> 4  )];
      pChar[2*i+1] = usHexToChar[(pBCD[i] & 0x0F)];
   }
   pChar[2*BCDLen] = 0;
   return;   
}

void ChartoBCD(uchar *pChar, uint CharLen, uchar *pBCD)
{
	uchar ucTmp;
	uint  i;

	for(i=0; i<CharLen; i+=2)
	{
		ucTmp= pChar[i];
		if (ucTmp==0x00)
		 ucTmp= 0x00;
		else if (ucTmp<'A')
			ucTmp= ucTmp - '0';
		else
			ucTmp= toupper(ucTmp) - 'A' + 0x0A;

		ucTmp<<= 4;
		pBCD[i/2]= ucTmp;

		ucTmp= pChar[i+1];
		if(ucTmp == 0x00)   ucTmp= 0x00;
		else if (ucTmp<'A')
			ucTmp= ucTmp - '0';
		else
			ucTmp= toupper(ucTmp) - 'A' + 0x0A;
		pBCD[i/2] = pBCD[i/2] + ucTmp;
	}
	if (CharLen & 0x01)
	{
		pBCD[CharLen/2] >>= 4;
		pBCD[CharLen/2+1] = 0;
	}
	else
		pBCD[CharLen/2] = 0;
	return;
}

////////////////////////////////////////////////R/W At24C0X functions
void	Ide_ARE(void)//lxj
{