tuner.c

此代码实现了飞利浦高频头的驱动

/******************************************************************************
 * Tuner.c DESCRIPTION: -
 * This file include functions of TUNER
 * 
 ******************************************************************************/
#include "All.h"

 code unsigned char TUNER_TYPE_DATA[4][4]= {
  //  D    B    C    E
    {0x00,0x56,0x72,0x4a},  // I   
    {0x00,0x56,0x72,0x49},  // B/G
    {0x00,0x46,0x50,0x4B},  // L
    {0x00,0x56,0x72,0x4B}
};  // D/K
/******************************************************************************
 * TUNER_IF_SetMode DESCRIPTION: - 
 * Set intermediate frequency (MHz) in the following mode.
 * 				PAL B/G	PAL D/K	PAL I 	L 		L'
 * Picture carrier 	38.90 	38.90 	38.90 	38.90 	33.95
 * Colour 		34.47 	34.47 	34.47 	34.47 	38.38
 * Sound 1 		33.40 	32.40 	32.90 	32.40 	40.45
 * Sound 2 		33.16      -		-		-		-  
 * NICAM 		33.05 	33.05 	32.35 	33.05 	39.80
 * 
 ******************************************************************************/
void TUNER_IF_SetMode(UBYTE mode)
{
	if(bBusOff)
		return;    
	I2COne_Start();
    	I2COne_DataIn(TUNER_SA1);
    	I2COne_DataIn(0);
    	I2COne_DataIn(TUNER_TYPE_DATA[mode][1]);
    	I2COne_DataIn(TUNER_TYPE_DATA[mode][2]);
    	I2COne_DataIn(TUNER_TYPE_DATA[mode][3]);
	I2COne_Stop();
}
/******************************************************************************
 * TUNER_IF_GetMode DESCRIPTION: - 
 * Get the intermediate frequency mode.
 * 
 ******************************************************************************/
UBYTE TUNER_IF_GetMode(UBYTE program)
{
	if(bBusOff)
		return 0;
	return E2PROM_ReadByte(EE_TUNER+4*program+2);
}	
/******************************************************************************
 * TUNER_IF_GetAfcLevel DESCRIPTION: - 
 * Get atuo frequency control level to judge if the PLL is lock.
 * 
 ******************************************************************************/
UBYTE TUNER_IF_GetAfcLevel(void)
{
	idata UBYTE i,value;
	if(bBusOff)
		return 0;
	i = 0;
IC_Read_again1:
	i++;
	if(i>20)
	{
		I2COne_Stop();
		return 0;
	}
	I2COne_Start();
	if(I2COne_DataIn(TUNER_SA1|1))
	    	goto IC_Read_again1;
	value = I2COne_DataOut();
	I2COne_Acknowledge(1);
	I2COne_Stop();
	return	(value>>1)&0x0F;
}
/******************************************************************************
 * TUNER_RF_GetBand DESCRIPTION: - 
 * Get the band of divider.
 * 
 ******************************************************************************/
UBYTE TUNER_RF_GetBand(UINT16 divider)
{
	if(divider>=TUNER_UHF_MIN)
	{
		return TUNER_UHF;    
	}
	else if(divider<TUNER_VHFL_MAX)
	{
		return TUNER_VHFL;    
	}
	else
	{
		return TUNER_VHFH;
	}
}
/******************************************************************************
 * TUNER_RF_SetStep DESCRIPTION: - 
 * Set the divider step, the return value is divider+step or divider-step. And the 
 * direction is determined by bUpDirection.
 *
 ******************************************************************************/
UINT16 TUNER_RF_SetStep(UINT16 divider,UBYTE step)
{
	if(bUpDirection)
	{
		divider+=step;		
	}
	else
	{
		divider-=step;		
	}
	return divider;
}
/******************************************************************************
 * TUNER_RF_SetDivider DESCRIPTION: - 
 * Set divider to the tuner.
 * 
 ******************************************************************************/
void TUNER_RF_SetDivider(UINT16 divider)
{
	if(bBusOff)
		return;
	I2COne_Start();
    	I2COne_DataIn(TUNER_SA);
    	I2COne_DataIn((divider>>8)&0x7F);
    	I2COne_DataIn(divider&0xFF);
    	I2COne_DataIn(0x88);
	switch(TUNER_RF_GetBand(divider))
	{
		case TUNER_VHFL :
	    		I2COne_DataIn(0x01);
			break;
		case TUNER_VHFH :
	    		I2COne_DataIn(0x02);
			break;
		case TUNER_UHF :
	    		I2COne_DataIn(0x04);
			break;
		default : break;
	}
	I2COne_Stop();
}
/******************************************************************************
 * TUNER_RF_GetDivider DESCRIPTION: - 
 * Get the divider of program, which saved in E2prom.
 * 
 ******************************************************************************/
UINT16 TUNER_RF_GetDivider(UBYTE program)
{
	idata UINT16 divider,addr;
	if(bBusOff)
		return 0;
	addr=EE_TUNER+4*program;
	divider=E2PROM_ReadByte(addr+1);
	divider<<=8;
	divider+=E2PROM_ReadByte(addr);
	return divider;
}	
/******************************************************************************
 * TUNER_RF_SearchEndCheck DESCRIPTION: - 
 * Check if search is end.
 * 
 ******************************************************************************/
void TUNER_RF_SearchEndCheck(void)
{
	idata UBYTE i;
	if(bAutoSearchOn)
	{
		if(g16Divider>=TUNER_UHF_MAX)
		{
			for(i=g08Program;i<=C_MAX_PROGRAM_NUMBER;i++)
			{
				TUNER_SaveSkip(g08Program,SKIP);
				E2PROM_WriteByte(EE_PRG_INDEX0+g08Program,g08Program);
			}
			bAutoSearchOn=FALSE;
		}
	}
	if(bManualSearch)
	{
		if(bUpDirection)
		{
			if(g16Divider>=TUNER_UHF_MAX)
			{
				g16Divider=TUNER_VHFL_MIN;
			}
		}
		else
		{
			if(g16Divider<=TUNER_VHFL_MIN)
			{
				g16Divider=TUNER_UHF_MAX;
			}
		}
	}
}
/******************************************************************************
 * TUNER_RF_SearchProgram DESCRIPTION: - 
 * Search program.
 * 
 ******************************************************************************/
void TUNER_RF_SearchProgram(void)
{
	idata UBYTE AFC;
	bSyncOn=HTV280DEC_GetHorizonSyn();
	AFC=TUNER_IF_GetAfcLevel();
	switch(g08AutoSearchStatus)
	{
		case(0):
			g16Divider=TUNER_RF_SetStep(g16Divider,20);
			TUNER_RF_SetDivider(g16Divider);
			g08AutoSearchStatus=1;
			g08TunerDelay=TIME_100MS;
			break;
		case(1):
			if(bSyncOn)
			{
				g08AutoSearchStatus=2;			     				     	     
			}
			else
			{
				g16Divider=TUNER_RF_SetStep(g16Divider,20);
				TUNER_RF_SetDivider(g16Divider);
				g08AutoSearchStatus = 1;	
				g08TunerDelay       = TIME_100MS;
			}   
			break;
		case(2):
			if(AFC!=7&&bSyncOn)
			{
				g08AutoSearchStatus=3;
			}
			else 
			{
				if(bSyncOn)
				{
					g16Divider=TUNER_RF_SetStep(g16Divider,5);
					TUNER_RF_SetDivider(g16Divider);
					g08TunerDelay=TIME_100MS;
				}	
				else 
				{
					g16Divider=TUNER_RF_SetStep(g16Divider,10);
					TUNER_RF_SetDivider(g16Divider);
					g08TunerDelay=TIME_100MS;
					g08AutoSearchStatus=1;		    
				}  
			}	
			break;
		case(3):
			if(bSyncOn)
			{		   					             	  		         
				if(((AFC>=0)&&(AFC<=2))||((AFC>=13)&&(AFC<=15)))
				{
					g08AutoSearchStatus=4;
					g08TunerDelay=TIME_60MS;
				}
				else
				{
					g16Divider=TUNER_RF_SetStep(g16Divider,1);
					TUNER_RF_SetDivider(g16Divider);
					g08TunerDelay=TIME_300MS;
				}
			}
			else
			{
				g16Divider=TUNER_RF_SetStep(g16Divider,20);
				TUNER_RF_SetDivider(g16Divider);
				g08TunerDelay=TIME_80MS;
				g08AutoSearchStatus=1;	             	   	
			} 
			break;
		case(4):
			TUNER_SaveSkip(g08Program,UNSKIP);
			E2PROM_WriteByte(EE_PRG_INDEX0+g08Program,g08Program);
			E2PROM_WriteByte(EE_TUNER+4*g08Program,g16Divider);
			E2PROM_WriteByte(EE_TUNER+4*g08Program+1,g16Divider>>8);
			E2PROM_WriteByte(EE_TUNER+4*g08Program+2,HD[HD_PICTURE_COLORSYSTEM]);
			if(bManualSearch)
			{
				bManualSearch=FALSE;
				g08AutoSearchStatus=0;
			}
			else
			{
				g08Program++;
				g08AutoSearchStatus=0;		     	        	    
			}
			break;  
		default:
			break;
	} 
	TUNER_RF_SearchEndCheck();
}
/******************************************************************************
 * TUNER_SaveSkip DESCRIPTION: - 
 * Save the program's skip information.
 * 
 ******************************************************************************/
void TUNER_SaveSkip(UBYTE program,UBYTE skip)
{
	idata UBYTE status;
	if(program<C_MAX_PROGRAM_NUMBER)
	{		
		status=E2PROM_ReadByte(EE_SKIP+(program>>3));
		if(skip)
			status|=0x01<<(program%8);
		else
			status&=~(0x01<<(program%8));
		E2PROM_WriteByte(EE_SKIP+(program>>3),status);
	}
}
/******************************************************************************
 * TUNER_isProgramSkip DESCRIPTION: - 
 * Check if program is skip or unskip.
 * 
 ******************************************************************************/
BOOL TUNER_isProgramSkip(UBYTE program)
{
	idata UBYTE status;
	if(program<C_MAX_PROGRAM_NUMBER)
	{
		status=E2PROM_ReadByte(EE_SKIP+(program>>3));
		if(status&(0x01<<(program%8)))
			return TRUE;
		else
			return FALSE;
	}
	return FALSE;
}
/******************************************************************************
 * TUNER_SwitchProgram DESCRIPTION: - 
 * Switch to certain program.
 * 
 ******************************************************************************/
void TUNER_SwitchProgram(UBYTE program)
{
	TUNER_RF_SetDivider(TUNER_RF_GetDivider(program));
	TUNER_IF_SetMode(TUNER_IF_GetMode(program));
}