scpu.c

单片机C51 源程序

#include<reg51.h>
#include<absacc.h>
#include<intrins.h>

#define uchar unsigned char
#define uint unsigned int

#define RAM_ADDR 0x0000
#define CONTROL_1 0x8000
#define CONTROL_2 0xa000
#define COMM_CPU  0xc000

#define CMH 0x18
#define CML 0x10
#define DAT 0x08
#define MSGMODE 0x40
#define SPLIT 0x80

#define OFF_HOOK_07 9
#define OFF_HOOK_8F 10
#define RING_07 8
#define RING_8F 9
#define TEST_07 10
#define TEST_8F 11
#define REVERSAL_07 12
#define REVERSAL_8F 13
#define DTMF_TS 16

uchar delay, err=0;
uchar xdata *RecBufPtr =  RAM_ADDR;

uchar data pre_status[2] = {0xff,0xff};
uchar data cur_status ;

uchar data TimeCount100ms = 25;
uchar data TimeCount1s = 250;
uint data TimeCount4s = 1000;
uchar xdata UserStatus[16];
uchar xdata CallUser[16];
uchar xdata AnswerUser[16];
uchar xdata RingOn[16];
uchar xdata TelNumber[16][3];
uchar xdata ConvertTelNumber[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};

uint xdata *UserStatusPtr = UserStatus;
uint xdata *CallUserPtr = CallUser;
uint xdata *AnswerUserPtr = AnswerUser;
uint xdata *RingOnPtr = RingOn;


sbit p10 = P1^0;
sbit p16 = P1^6;
bit TxFlag = 0;
bit RxFlag = 0;
bit CallFlag = 0;

void connect(uint control, uchar input_stream, uchar input_channel, uchar output_stream, uchar output_channel);
void disable(uint control, uchar stream, uchar channel);
uchar ReadData(uint control,uchar stream, uchar channel);
void ControlSignal(uint control, uchar stream, uchar channel, uchar message);
void enable(uint control, uchar stream, uchar channel);
void InitialScpu(void);
void ScanUserStatus(void);
void StatusAnalysis(void);
void RingControl(void);
void DisableRing(void);
void Timer0Int(void);
void delayxs(uchar);
void SendDataToMcpu(uchar);
uchar ReadDataFromMcpu(void);
void Compare(uchar, uchar);

void main(void)
{
//   uchar temp;

   InitialScpu();
    disable(CONTROL_1,5, 15);
                        disable(CONTROL_1,6, 31);

   p16 = 0;
   _nop_();
   p16 = 1;

   while(1)
   {
        uchar i,j,k,tmp ;
        uchar call_num=0;

        cur_status = ReadData(CONTROL_2, 5, 8);
        while(!(cur_status == 0x07));
        
         cur_status = ReadData(CONTROL_2, 5, 9);
         while(!(0x01&cur_status));
         
           ControlSignal(CONTROL_2, 5, 9, 0x80);
           while(!(0x80 & ReadData(CONTROL_2, 5, 10)));
           ControlSignal(CONTROL_2, 5, 9, 0x00);
           connect(CONTROL_1, 5, 15, 5, 0);
 			enable(CONTROL_1,5, 0);
                        connect(CONTROL_1, 5, 0, 5, 15);
 			enable(CONTROL_1,5, 15);
                         tmp=ReadData(CONTROL_2, 5, 9);
                        while(!(0x00&tmp));
                        disable(CONTROL_1,5, 15);
                         disable(CONTROL_1,5, 0);
                         while(1);
                         
                        
                        
                        


/*   
        cur_status =~ReadData(CONTROL_2, 6, 26);

        if(0x80&cur_status)
        {       connect(CONTROL_1, 0, 1, 6, 31);
 			enable(CONTROL_1,6, 31);
                ControlSignal(CONTROL_2, 6, 25, 0x80);

                tmp = ReadData(CONTROL_2, 5, 9);
                while(!(0x80&tmp))
                {
                RingControl();
                tmp = ReadData(CONTROL_2, 5, 9);
                }
                      ControlSignal(CONTROL_2, 5, RING_8F, 0x00);
        	       connect(CONTROL_1, 5, 15, 6, 31);
 			enable(CONTROL_1,6, 31);
                        connect(CONTROL_1, 6, 31, 5, 15);
 			enable(CONTROL_1,5, 15);

                 while(1);
          }
                                      */
        /*
        connect(CONTROL_1, 0, 1, 5, 0);
 			enable(CONTROL_1,5, 0);
         ControlSignal(CONTROL_2, 6, 25, 0x80);
        	connect(CONTROL_1, 5, 0, 6, 31);
 			enable(CONTROL_1,6, 31);
            connect(CONTROL_1, 6, 31, 5, 0);
 			enable(CONTROL_1,5, 0);
                        disable(CONTROL_1,5, 0);
                        disable(CONTROL_1,6, 31);    */
        }
 }

           /* while(!RxFlag);
    		temp = ReadDataFromMcpu();
    		RxFlag = 0;

            if(RecBufPtr<=0x7fff)
            {
            	 *RecBufPtr = temp;
                 rx_data = temp;
                 RecBufPtr++;
            }
            else
            {
                 RecBufPtr = RAM_ADDR;
                 *RecBufPtr = temp;
          	     rx_data = temp;
                 RecBufPtr++;
            }
            Compare(tx_data, rx_data);    */



          /*

		if(!TimeCount100ms)
		{
			TimeCount100ms = 25;
			ScanUserStatus();
		}

		for(i=0;i<16;i++)
		{
			if(0x80 & UserStatus[i])				//主叫摘机
			{
				 CallUser[call_num] = &(UserStatusPtr+i);
				 connect(CONTROL_1, 0, 1, 5, CallUser[call_num]);
 				 enable(CONTROL_1,5, CallUser[call_num]);
 				 connect(CONTROL_1, 5, CallUser[call_num], 0, DTMF_TS+i);
 				 enable(CONTROL_1,0, DTMF_TS+i);
 				 call_num++;
 			}

			else if(0x02 & UserStatus[i])		//被叫摘机
			{

			}



 		}

        for(k=0;k<call_num;k++)
 	    {
 		   if(0x08&ReadData(CONTROL_2,0,DTMF_TS+k))
 		   {
 				disable(CONTROL_1,5, CallUser[k]);
 				TelNumber[k][2] = ReadData(CONTROL_2,0,DTMF_TS+k);
 				while(!(0x08&ReadData(CONTROL_2,0,DTMF_TS+k)));
 				TelNumber[k][1] = ReadData(CONTROL_2,0,DTMF_TS);

 				TelNumber[k][0] = CallUser[k];

 				disable(CONTROL_1,0, DTMF_TS+k);

 				SendDataToMcpu(TelNumber[k][0]);
 				SendDataToMcpu(TelNumber[k][1]);
 				SendDataToMcpu(TelNumber[k][2]);
 		   }
 		   RingOn[k] = TelNumber[k][1] + TelNumber[k][0]>>4;
 	   }

 	   RingControl();

 	   for(i=0;i<16;i++)
 	   {
 			for(j=0;j<16;j++)
 			{
 				if(0x0f&RingOn[i]==0x0f&CallUser[j])
 					AnswerUser[i] = RingOn[i];
 			}

 	   }

 	   ControlSignal(CONTROL_2, 5, RING_07, 0x00);
       ControlSignal(CONTROL_2, 5, RING_8F, 0x00);

       connect(CONTROL_1, 5, 0x0f&RingOn[0], 5, 0x0f&&CallUser[0]);
 	   enable(CONTROL_1,5, 0x0f&CallUser[0]);
 	   connect(CONTROL_1, 5, 0x0f&CallUser[0], 5,0x0f&&RingOn[0] );
 	   enable(CONTROL_1, 5,0x0f&RingOn[0]);

 	}

 }
                    */

void InitialScpu(void)
{
    p10 = 1;
    p16 = 1;
    IE = 0;

	IP = 0x02;
	TMOD = 0x01;
	TR0 = 0;
	TL0 = (65536-4000) & 0xff;				//4ms
	TH0 = (65536-4000) >> 8;
	IT0 = 1;
	ET0 = 1;
	EX0 = 1;
	EA = 1;
	TR0 = 1;

    ControlSignal(CONTROL_2, 5, RING_07, 0x00);
    ControlSignal(CONTROL_2, 5, RING_8F, 0x00);
    ControlSignal(CONTROL_2, 5, TEST_07, 0x00);
    ControlSignal(CONTROL_2, 5, TEST_8F, 0x00);

    ControlSignal(CONTROL_2, 6, 24, 0x00);
    ControlSignal(CONTROL_2, 6, 25, 0x00);
    ControlSignal(CONTROL_2, 6, 26, 0x00);
    ControlSignal(CONTROL_2, 6, 27, 0x00);



}


/**********************************************************************************************
*
* This routine sets up a connection between an input channel and an output
* channel.
*
***********************************************************************************************/

void connect(uint control, uchar input_stream, uchar input_channel, uchar output_stream, uchar output_channel)
{
	uchar temp;
	uchar connection_pointer;

	XBYTE[control] = 0x18 + output_stream;				// Select CMH of the output stream

	delay = 0;											// Software delay

	temp = XBYTE[control + 0x20 + output_channel];			// Store the contents of CMH
	temp = XBYTE[control + 0x20 + output_channel];
	temp = temp & 0xFB;										//Enable connection mode by setting bit 2 of CMH low
	XBYTE[control + 0x20 + output_channel] = temp;

	delay = 0;

	XBYTE[control] = 0x10 + output_stream;				// Select CML of output stream

	connection_pointer = input_stream;				// Assemble connection pointer
	connection_pointer = connection_pointer << 5;
	connection_pointer = connection_pointer + input_channel;

	XBYTE[control + 0x20 + output_channel] = connection_pointer;		// Set up connection

	delay = 0;
}


/****************************************
*
* This routine enables a channel.
*
****************************************/

void enable(uint control, uchar stream, uchar channel)
{
	uchar temp;

	XBYTE[control] = 0x18 + stream;				// Go to CMH of stream

	temp = XBYTE[control + 0x20 + channel];			// Store contents of CMH
	temp = XBYTE[control + 0x20 + channel];
	temp = temp | 1;								// Enable channel by setting bit 0 of CMH high
	XBYTE[control + 0x20 + channel] = temp;

	delay = 0;
}

/****************************************
*
* This routine disables a channel.
*
****************************************/

void disable(uint control, uchar stream, uchar channel)
{
	uchar temp;

	XBYTE[control] = 0x18 + stream;				// Go to CMH of stream

	temp = XBYTE[control + 0x20 + channel];			// Store contents of CMH
	temp = XBYTE[control + 0x20 + channel];
	temp = temp & 0xFE;								// Disable channel by setting bit 0 of CMH low
	XBYTE[control + 0x20 + channel] = temp;

	delay = 0;
}

/*************************************************************************************************************
*
* This routine places a channel in message mode and places a bit pattern in the channel.
*
*************************************************************************************************************/

void ControlSignal(uint control,uchar stream, uchar channel, uchar message)
{

		XBYTE[control] = MSGMODE | CMH | stream;
        delay = 0;

        XBYTE[control + 0x20 + channel] = 0x05;
        delay = 0;

        XBYTE[control] = MSGMODE | CML | stream;
        delay = 0;

		XBYTE[control + 0x20 + channel] = message;		// Write message to channel
 		delay = 0;

 }


uchar ReadData(uint control,uchar stream, uchar channel)
{
	uchar temp;

	XBYTE[control] = SPLIT | stream;			//  0x85;

	delay = 0;

	temp = XBYTE[control + 0x20 + channel];
    temp = XBYTE[control + 0x20 + channel];
	delay = 0;

	return(temp);


}


void Timer0Int(void) interrupt 1 using 2
{
	 TR0 = 0;
     TimeCount1s--;
     TimeCount4s--;
     TimeCount100ms--;
	 TL0 = (65536-4000) & 0xff;
	 TH0 = (65536-4000) >> 8;
	 TR0 = 1;

 }

void ExInt0(void) interrupt 0 using 3
{
	EX0 = 0;
	RxFlag = 1;
	EX0 = 1;

}

/***************************************************************
*   D7: 主叫摘机；D6: 挂机；D4: 通话；D1: 被叫摘机；D0:  振铃  *
***************************************************************/

void ScanUserStatus(void)
{
	uchar i;

	cur_status = ~ReadData(CONTROL_2, 5, OFF_HOOK_07);
	if(~cur_status&pre_status[0])
	{
		for(i=0;i<8;i++)
		{
			if(0x01&(~cur_status>>i))
			{
				if(!(0x01 & CallUser[i]))
					CallUser[i] = 0x80 | CallUser[i];			//主叫摘机
				else
					CallUser[i] = 0x02;						    //被叫摘机
			}
		}
	}
	pre_status[0] = cur_status;

    cur_status = ~ReadData(CONTROL_2, 5, OFF_HOOK_8F);
	if(~cur_status&pre_status[1])
	{
		for(i=0;i<8;i++)
		{
			if(0x01&(~cur_status>>i))
			{
				if(!(0x01 & CallUser[i+8]))
					CallUser[i+8] = 0x80 | CallUser[i+8];
				else
					CallUser[i+8] = 0x02;
			}
		}
	}
	pre_status[1] = cur_status;

}


void RingControl(void)
{
	uchar i;

//	for(i=0;i<16;i++)
//	{
	/*	if(RingOn[i]<8)
			ControlSignal(CONTROL_2, 5, RING_07, ConvertTelNumber[RingOn[i]]);
		else    */
			ControlSignal(CONTROL_2, 5, RING_8F, 0x80);
    //	TimeCount1s = 250;
    	if(!TimeCount1s)
    	{
    		ControlSignal(CONTROL_2, 5, RING_07, 0);
    		ControlSignal(CONTROL_2, 5, RING_8F, 0);
    		TimeCount4s = 1000;
    		if(!TimeCount4s)
    		{
    		/*	if(RingOn[i]<8)
					ControlSignal(CONTROL_2, 5, RING_07, ConvertTelNumber[RingOn[i]]);
				else     */
					ControlSignal(CONTROL_2, 5, RING_8F, 0x80);
    			TimeCount1s = 250;
    		}
    	}
   // }

}


void DisableRing(void)
{
	ControlSignal(CONTROL_2, 5, RING_07, 0x00);
   	ControlSignal(CONTROL_2, 5, RING_8F, 0x00);

}

void delayxs(uchar time)
{
	uchar i, j;
	for(j=0;j<time;j++)
		for(i=0;i<0xff;i++)
			_nop_();
}


void SendDataToMcpu(uchar tx_data)
{
	XBYTE[COMM_CPU] = tx_data;
	delayxs(10);
 	p10 = 1;
    _nop_();
    p10 = 0;
    _nop_();
    p10 = 1;
}


uchar ReadDataFromMcpu(void)
{
	uchar temp;
	temp = XBYTE[COMM_CPU];
	return(temp);
}

void Compare(uchar tx_value, uchar rx_value)
{
	if(tx_value == rx_value)
		err = 0;
	else
		err++;
}