comm.c

SPWM三相波形发生器

#include <reg52.h>
#include <string.h>
#include <absacc.h>
#include <menuaddress.h>

#define uchar unsigned char
#define uint  unsigned int

#define	XTAL	   11059200	/* CPU Oscillator Frequency *///
#define	EXP_XTAL	11059200//   14745600

sbit LED = P3^7;
sbit PD =  P3^6;
sbit ERST = P3^4;
sbit PWDN =  P2^4;

//define int number
#define		DEF_INT_EX0				0
#define		DEF_INT_TIME0			1
#define		DEF_INT_EX1				2
#define		DEF_INT_TIME1			3
#define		DEF_INT_ASYNC			4

#define		DEF_COMMBUFF_LEN		32
#define		EXP_COMMBUFF_LEN		32
#define		DEF_PARITY_NON			0x00
#define		DEF_PARITY_EVEN			0x01
#define		DEF_PARITY_ODD			0x02
#define		DEF_PARITY_2STOP		0x03

extern void ModemSend(uchar *String);
extern	void  ModemRead(uchar *String,uchar Len);

void	_AsyncOpen(uint Baud, uchar Parity);
//void	_AsyncClose(void);
bit		_AsyncPutTest(void);
void	_AsyncPut(uchar ucValue);
bit		_AsyncGetTest(void);
uchar	_AsyncGet(void);


uchar	idata	PUB_CommBuffR[DEF_COMMBUFF_LEN];
uchar	idata	PUB_CommBuffT[DEF_COMMBUFF_LEN];
uchar	idata	PUB_CountRH, PUB_CountRT;
uchar	idata	PUB_CountTH, PUB_CountTT;
uchar	idata	PUB_ByteTT;
uchar	idata	PUB_CommParity;
extern	bit 	PUB_Async_TI ;
extern	bit 	PUB_Async_RI ;
uchar	idata	PUB_Async_RecData;

uchar	idata	Volume;
uchar	data	Vol_Rec;


//-------main.c-----------
extern	uchar	idata	input[32]; 
extern unsigned char idata tempbuf[32];
extern	void Delay(uint x);

//------EEPROM.c----------
extern void ReadUserBlock(uchar idata *input,uint Address,uchar Number);

void  _SysInit(void)
{
    EA = 0;
    IT1 = 0x01;
//	RCAP2H = 0xDC;	//11.0592M
//	RCAP2L = 0x00;
	RCAP2H = 0xe8;	//7.3728
	RCAP2L = 0x00;
	TH2 = 0xDC;
	TL2 = 0x00;
	TR2 = 1;
	ET2 = 1;
	Volume = 0x35;
    EA = 1;
}

void  _EXP_InfoRec(void)
{
	uchar i,j;

			ModemRead(input,sizeof(input));
			if(strcmp(input,"RING")==0)
			{
				ModemRead(input,sizeof(input));
				ModemRead(input,sizeof(input));
				for (i=1;i<sizeof(input)-1;i++)
				{
					if(input[i]=='"')input[i]=0;
				}
				j = 0;
				for (i=0;i<2;i++)
				{
					ReadUserBlock( tempbuf, Fixed_IP+(i*32),sizeof(tempbuf));
					if(strlen(input)<4)break;
					if(strlen(tempbuf)<4)continue;
					for (j=0;j<sizeof(tempbuf)-1;j++)
					{
						if(tempbuf[strlen(tempbuf)-1-j]!=input[strlen(input)-1-j])
							break;
						if((j==strlen(tempbuf)-1)||(j==strlen(input)-2))
						{
							j=sizeof(tempbuf);
							break;
						}
					}
					if(j==sizeof(tempbuf))break;
				}
				ModemRead(input,sizeof(input));
				if(strcmp(input,"RING")==0)
				{
					Delay(100);
					if(j==sizeof(tempbuf))
					{
						ModemSend("ATA\r");
						PWDN = 0;Vol_Rec = 0;
						IE1 = 0;
						EX1 = 1;
					}
					else
					{
						ModemSend("ATH\r");
						PWDN = 1;
						EX1 = 0;
						Delay(100);
						ModemSend("AT+CFUN=0\r");
					}
				}
				else
					ModemSend("AT+CFUN=0\r");
			}
			else if(strcmp(input,"NO")==0)
			{
				ModemRead(input,sizeof(input));
				if((strcmp(input,"ANSWER")==0)||(strcmp(input,"CARRIER")==0))
				{
					Delay(100);
					ModemSend("ATH\r");
					PWDN = 1;
					EX1 = 0;
					Delay(100);
					ModemSend("AT+CFUN=0\r");
				}
			}
}

void  Switch_OFF(void)
{
	EA = 0;
//	ModemSend("AT^SMSO\r");
	PD = 0;
	ERST = 0;
	PWDN = 1;
	PCON = 0x02;
}


void  Vol_control(void)
{
	uchar cc;

	cc = P2&0x0f;
	strcpy(tempbuf,"AT^SNFI=0,32768\r");
	if(cc==0x08)
	{
		{
			if((Volume<0x37)&&(Volume>=0x30))
			{
				Volume = Volume + 1;
				tempbuf[8] = Volume;
				ModemSend(tempbuf);
			}
		}
	}
	else if(cc==0x04)
	{
		{
			if((Volume>0x30)&&(Volume<=0x37))
			{
				Volume = Volume - 1;
				tempbuf[8] = Volume;
				ModemSend(tempbuf);
			}
		}
	}
}

void int_ex1(void) interrupt DEF_INT_EX1
{
	Vol_Rec = 1;
}

_IntAsync()		interrupt DEF_INT_ASYNC
{
	if ( RI == 0 )
    {
		TI = 0;
	    PUB_Async_TI = 1;
		PUB_CountTT++;
			if (PUB_CountTT >= DEF_COMMBUFF_LEN)	PUB_CountTT = 0;
		if ( PUB_CountTH != PUB_CountTT )
		{

			PUB_ByteTT = PUB_CommBuffT[PUB_CountTT];
			ACC = PUB_ByteTT;
			TB8 = P;
			if ( PUB_CommParity == DEF_PARITY_ODD )
				TB8 = TB8 ^ 0x01;
			if ( PUB_CommParity == DEF_PARITY_2STOP )
				TB8 = 1;
			SBUF = PUB_ByteTT;
		}
    }
    else
    {
        RI = 0;
        PUB_Async_RecData = SBUF;
		PUB_Async_RI = 0;
		switch ( PUB_CommParity )
		{
			case DEF_PARITY_ODD:
				ACC = PUB_Async_RecData;
				if ( (P^0x01) == RB8  )
					PUB_Async_RI = 1;
				break;
			case DEF_PARITY_EVEN:
				ACC = PUB_Async_RecData;
				if ( P == RB8  )
					PUB_Async_RI = 1;
				break;
			case DEF_PARITY_2STOP:
				ACC = PUB_Async_RecData;
				if (  RB8 ==1 )
					PUB_Async_RI = 1;
				break;
			default:
				PUB_Async_RI = 1;
		}
//		if ( PUB_Async_RI )
		{
			PUB_CommBuffR[PUB_CountRH] = PUB_Async_RecData;
			PUB_CountRH++;
			if (PUB_CountRH >= DEF_COMMBUFF_LEN-1)	PUB_CountRH = 0;
		}
	}
}

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

    ES = 0;
	RI = TI =0;

    THData = 0xfe;
    switch ( Baud )
    {
		case 19200:  THData = 0xfe; break;
		case  9600:  THData = 0xfe; break;
		case  4800:  THData = 0xfc; break;
		case  2400:  THData = 0xf8; break;
		case  1200:  THData = 0xf0; break;
    }
	if (Baud==19200)
		PCON|= 0x80;
	else
		PCON&= 0x7f;
    PUB_CommParity = Parity;
    TR1  = 0x00;
    cc = TMOD;
    TMOD = (cc & 0x0f) | 0x20;
//    if (Parity==DEF_PARITY_NON)
		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;

	PUB_CountRH = PUB_CountRT = 0;
	PUB_CountTH = PUB_CountTT = 0;
    return;
}

bit  _AsyncPutTest(void)
{
	return PUB_Async_TI;
}

void _AsyncPut(uchar ucValue)
{

	if ( PUB_Async_TI == 0)
		return;
	ES = 0;
	if (PUB_CountTH == PUB_CountTT)
	{
		PUB_ByteTT = ucValue;
		ACC = PUB_ByteTT;
		TB8 = P;
		if ( PUB_CommParity == DEF_PARITY_ODD )
			TB8 = TB8 ^ 0x01;
		if ( PUB_CommParity == DEF_PARITY_2STOP )
			TB8 = 1;
		SBUF = ucValue;
	}

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


bit  _AsyncGetTest(void)
{
	if ( PUB_CountRH != PUB_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;
}