pll62.c

另一个比较完整的MC145162示例程序

/******************************************************************************
This program performs a PLL used the MC145162.

	Complier 	:	Franklin PV32 Version 3.3
	date		:	2003/6/12	created.
	
*//////////////////////////////////////////////////////////////////////////////	

#include <reg52.h>
#include <intrins.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
///////////////////////////////////////////////////////////////////////////////
/**************************************************/
/* port define */
sfr p_Lcd_Data=0x80;
/* P0 was used to the Lcd's DB0--DB7 */

sbit bp_Pll_Enb=P1^0;
sbit bp_Pll_Data=P1^1;
sbit bp_Pll_AData=P1^2;
sbit bp_Pll_Clk=P1^3;
/* Others was not used */

sbit bp_Key_Inc=P2^0;
sbit bp_Key_Dec=P2^1;
sbit bp_Key_Step=P2^2;
sbit bp_Key_Set=P2^3;
sbit bp_Lcd_Rw=P2^4;		// 
sbit bp_Lcd_E=P2^5;	// 
sbit bp_Lcd_Rs=P2^6;
/* P2^7 was not used */

/* redifine the RX & TX for commuction with SERVOSTAR */
sbit bp_RX=P3^2;
sbit bp_TX=P1^2;
/* end port define */
/***************************************************/
/* Constant define */

/* status */
#define K_IDLE			0
#define K_INC			1
#define K_DEC			2
#define K_STEP			3
#define K_SET			4

/* timer */
#define K_TH0			0x3c
#define K_TL0			0xb0	// per 100mS

#define DEBUG			0

/* end constant define */
/****************************************************/
/* Var define */
unsigned char data ucCommand;		/* the command */
unsigned char data uc10M,uc1M,uc100K,uc10K,uc1K,ucStep,uc200ms;
unsigned char data ucTemp;

char data cDisp[]="07.050MHz     1K";
unsigned int data unFreq,unTemp;
					
void delay(unsigned char n);
void HandleCommand();
void InitLCD();
void UpdateLCD();
void WriteLCDCommand(char ucLCDCommand);
void WriteLCDData(char cLCDData);
void WriteFreq(unsigned int unCounter);
void WritePLLControl(char cControl);
void WritePLLReference(int nReference1,int nReference2);
void WritePLLTransmitReceive(int nTransmit,int nReceive);

void delay(unsigned char n)
{
	while(n--);
}

void delay_ms(unsigned char n)
{
	unsigned char i;
	for(i=0;i<n;i++){delay(120);}
}

void delay_1s()
{
	unsigned char i;
	for(i=0;i<5;i++){delay_ms(200);}
}

void service_timer0() interrupt 1 using 1	// interrupt per 100ms.
{
	TH0=K_TH0;
	TL0=K_TL0;

	if(uc200ms == 0)
	{
		if(!bp_Key_Inc)ucCommand = K_INC;
		if(!bp_Key_Dec)ucCommand = K_DEC;
		if(!bp_Key_Set)ucCommand = K_SET;
		if(!bp_Key_Step)ucCommand = K_STEP;
	
	   uc200ms = 1;
	   return;
	}
	else
	{
		uc200ms--;
		return;
	} 
}

void Prepare()
{

	P0 = 0xff;
	P1 = 0xff;
	P2 = 0xff;
	P3 = 0xff;

	bp_Pll_Enb = 0;
	bp_Pll_Data = 0;
	bp_Pll_Clk = 0;
	bp_Pll_AData =0;
	
	ucCommand = K_IDLE;

	IP=0x00;
	TCON = 0x00;
	TMOD=0x21;
	TH0=K_TH0;
	TL0=K_TL0;
	SCON = 0x50;
	TH1 = 0xfd;
	TL1 = 0xfd;
	IE = 0x00;
	ES = 0;
//	TR0 = 0;
	TR0 = 1;
	TR1 = 1;
	RI = 0;
	TI = 0;
	ET0 = 1;
//	ET0 = 0;
	EX0 = 0;
	EA = 1;

	WritePLLControl(0x80);
	WritePLLReference(0x60f0/*0x35dc*/,0xd770/*0x8000*/);
	WriteFreq(11050);
	
	uc10M = 0;
	uc1M = 7;
	uc100K = 0;
	uc10K = 5;
	uc1K = 0;
	ucStep = 0;
	uc200ms = 1;
	InitLCD();
	

}

void HandleCommand()
{
	switch(ucCommand)
	{
		case K_IDLE:
		break;
		case K_INC:
		if(unFreq > 50000)break;    //2.
		switch(ucStep)
		{
			case 4:
/*			ucTemp = uc10M;
			ucTemp++;
			if(ucTemp==6)ucTemp=0;
			uc10M = ucTemp;
*/
			unFreq += 10000;     //2.
			break;
			case 3:
/*			
			ucTemp = uc1M;
			ucTemp++;
			if(ucTemp==10)ucTemp=0;
			uc1M = ucTemp;
*/
			unFreq += 1000;	//2.
			break;
			case 2:
/*			
			ucTemp = uc100K;
			ucTemp++;
			if(ucTemp==10)ucTemp=0;
			uc100K = ucTemp;
*/
			unFreq += 100;  //2.
			break;
			case 1:
/*
			ucTemp = uc10K;
			ucTemp++;
			if(ucTemp==10)ucTemp=0;
			uc10K = ucTemp;
*/
			unFreq += 10;		//2.
			break;
			case 0:
/*			
			ucTemp = uc1K;
			ucTemp++;
			if(ucTemp==10)ucTemp=0;
			uc1K = ucTemp;
*/
			unFreq++;	//2.
			break;
		}
//		unFreq = uc10M * 10000 + uc1M * 1000 + uc100K * 100 + uc10K * 10 + uc1K;
//		unFreq += 4000;		// the IF = 4.000MHz
		WriteFreq(unFreq+4000);		// add the IF.
// the part is 2 Edition.
		unTemp =  unFreq;
		uc1K = unTemp % 10;
		unTemp = unTemp / 10;
		uc10K =  unTemp % 10;
		unTemp = unTemp / 10;
		uc100K = unTemp % 10;
		unTemp = unTemp / 10;
		uc1M = unTemp % 10;
		unTemp = unTemp / 10;
		uc10M = unTemp % 10;
////////////////////////////////////////////		
		UpdateLCD();
		ucCommand = K_IDLE;
  		break;
  		case K_DEC:
		switch(ucStep)
		{
			case 4:
/*			ucTemp = uc10M;
			if(ucTemp==0)ucTemp=5;
			else ucTemp--;
			uc10M = ucTemp;
*/
			if(unFreq < 10000)break;  //2.
			unFreq -= 10000;          //2.
			break;
			case 3:
/*			ucTemp = uc1M;
			if(ucTemp==0)ucTemp=9;
			else ucTemp--;
			uc1M = ucTemp;
*/
			if(unFreq < 1000)break; 	//2.
			unFreq -= 1000;            //2.
  			break;
			case 2:
/*			
			ucTemp = uc100K;
			if(ucTemp==0)ucTemp=9;
			else ucTemp--;
			uc100K = ucTemp;
*/
			if(unFreq < 100)break; 	//2.
			unFreq -= 100;            //2.
			break;
			case 1:
/*			
			ucTemp = uc10K;
			if(ucTemp==0)ucTemp=9;
			else ucTemp--;
			uc10K = ucTemp;
*/
			if(unFreq < 10)break; 	//2.
			unFreq -= 10;            //2.
			break;
			case 0:
/*
			ucTemp = uc1K;
			if(ucTemp==0)ucTemp=9;
			else ucTemp--;			
			uc1K = ucTemp;
*/
			if(unFreq < 1)break; 	//2.
			unFreq -= 1;            //2.
			break;
		}
//		unFreq = uc10M * 10000 + uc1M * 1000 + uc100K * 100 + uc10K * 10 + uc1K;
//		unFreq += 4000;
		WriteFreq(unFreq+4000);
// the part is 2 Edition.
		unTemp =  unFreq;
		uc1K = unTemp % 10;
		unTemp = unTemp / 10;
		uc10K =  unTemp % 10;
		unTemp = unTemp / 10;
		uc100K = unTemp % 10;
		unTemp = unTemp / 10;
		uc1M = unTemp % 10;
		unTemp = unTemp / 10;
		uc10M = unTemp % 10;
////////////////////////////////////////////									
		UpdateLCD();
		ucCommand = K_IDLE;
  		break;
		case K_STEP:
		ucStep++;
		if(ucStep==5)ucStep=0;
		UpdateLCD();
		ucCommand = K_IDLE;
  		break;
		case K_SET:
		ucCommand = K_IDLE;
		break;
	}
	
}

void WriteFreq(unsigned int unCounter)
{
	WritePLLTransmitReceive(unCounter,0);	
}

void WritePLLControl(char cControl)
{
	unsigned char i;
	
	bp_Pll_Enb = 1;
	delay(10);
	
	for(i=0;i<8;i++)
	{
		if(cControl&0x80)
			bp_Pll_Data = 1;
		else bp_Pll_Data = 0;
		
		cControl = cControl<<1;
		
		delay(5);
		bp_Pll_Clk = 1;
		delay(5);
		bp_Pll_Clk = 0;
	}
	bp_Pll_Data = 0;
	delay(10);
	bp_Pll_Enb = 0;
}

void WritePLLReference(int nReference1,int nReference2)
{
	unsigned char i;
	
	bp_Pll_Enb = 1;
	delay(10);
	
	for(i=0;i<16;i++)
	{
		if(nReference1&0x8000)
			bp_Pll_Data = 1;
		else bp_Pll_Data = 0;
		
		nReference1  = nReference1<<1;
		delay(5);
		bp_Pll_Clk = 1;
		delay(5);
		bp_Pll_Clk = 0;
	}
	
	for(i=0;i<16;i++)
	{
		if(nReference2&0x8000)
			bp_Pll_Data = 1;
		else bp_Pll_Data = 0;
		
		nReference2  = nReference2<<1;
		delay(5);
		bp_Pll_Clk = 1;
		delay(5);
		bp_Pll_Clk = 0;
	}

	bp_Pll_Data = 0;
	delay(10);
	bp_Pll_Enb = 0;
}

void WritePLLTransmitReceive(int nTransmit,int nReceive)
{
	unsigned char i;
	
	bp_Pll_Enb = 0;
	delay(10);
	
	for(i=0;i<16;i++)
	{
		if(nTransmit&0x8000)
			bp_Pll_Data = 1;
		else bp_Pll_Data = 0;
		
		nTransmit = nTransmit<<1;
		delay(5);
		bp_Pll_Clk = 1;
		delay(5);
		bp_Pll_Clk = 0;
	}
	
	for(i=0;i<15;i++)
	{
		if(nReceive&0x8000)
			bp_Pll_Data = 1;
		else bp_Pll_Data = 0;
		
		nReceive  = nReceive<<1;
		delay(5);
		bp_Pll_Clk = 1;
		delay(5);
		bp_Pll_Clk = 0;
	}

	if(nReceive&0x8000)			// the last clock.
		bp_Pll_Data = 1;
	else bp_Pll_Data = 0;
	
	delay(5);
	bp_Pll_Clk = 1;
	delay(3);
	bp_Pll_Enb = 1;
	delay(2);
	bp_Pll_Clk = 0;
	bp_Pll_Data = 0;
	delay(10);
	bp_Pll_Enb = 0;	
}


void WriteLCDCommand(char cLCDCommand)
{
	bp_Lcd_Rs = 0;
	bp_Lcd_Rw = 0;
	bp_Lcd_E = 1;
	delay(10);
	p_Lcd_Data = cLCDCommand;
	delay(10);
	bp_Lcd_E = 0;
	delay(100);
}

void WriteLCDData(char cLCDData)
{
	bp_Lcd_Rs = 1;
	bp_Lcd_Rw = 0;
	bp_Lcd_E = 1;
	delay(10);
	p_Lcd_Data = cLCDData;
	delay(10);
	bp_Lcd_E = 0;
	delay(100);
}

void InitLCD()
{
	unsigned char i;
	
	unFreq = 7050;
	
	bp_Lcd_Rs = 0;
	bp_Lcd_Rw = 0;
	bp_Lcd_E = 0;
	delay_ms(10);
	
	WriteLCDCommand(0x38);
	WriteLCDCommand(0x38);
	WriteLCDCommand(0x38);
	WriteLCDCommand(0x38);
	WriteLCDCommand(0x08);
	WriteLCDCommand(0x01);
	WriteLCDCommand(0x06);
	WriteLCDCommand(0x0c);

	
	WriteLCDCommand(0x80);
	for(i=0;i<8;i++)
		WriteLCDData(cDisp[i]);
	WriteLCDCommand(0xc0);
	for(i=8;i<16;i++)
		WriteLCDData(cDisp[i]);
}



void UpdateLCD()
{
	unsigned char i;
	
	switch(ucStep)
	{
		case 0:
		strcpy(cDisp+12,"  1K");
		break;
		case 1:
		strcpy(cDisp+12," 10K");
		break;
		case 2:
		strcpy(cDisp+12,"100K");
		break;
		case 3:
		strcpy(cDisp+12,"  1M");
		break;
		case 4:
		strcpy(cDisp+12," 10M");
		break;
	}
	
	cDisp[0]=uc10M + 0x30;
	cDisp[1]=uc1M + 0x30;
	cDisp[3]=uc100K + 0x30;
	cDisp[4]=uc10K + 0x30;
	cDisp[5]=uc1K + 0x30;
	
	WriteLCDCommand(0x80);
	for(i=0;i<8;i++)
		WriteLCDData(cDisp[i]);
	WriteLCDCommand(0xc0);
	for(i=8;i<16;i++)
		WriteLCDData(cDisp[i]);}

/****************************************************************/
void main()
{
	delay_ms(1);
	Prepare();

	for(;;)
	{
		HandleCommand();
	}

}