tunerrds.c

关于收音功能代码,并且显示在OSD和VFD上

/**************************************************************************************/
/***********************                    BBK CONFIDENTIAL                   ************************/
/***********************                                                                    ************************/
/***********************         Description : Digital Audio Process          ************************/
/***********************                                                                    ************************/
/*********************** Company: BBK AV ELECTRONICS CORP.,LTD ************************/
/***********************                                                                    ************************/
/***********************              Programmer : Terry Lee                  ******** ****************/
/**************************************************************************************/

#define TUNERRDS_PAR
#pragma NOAREGS
#include "general.h"
#include "..\..\procdef.h"
#include "..\..\typedef.h"
#include "..\..\vardef.h"


#ifdef BBK_RD2_RDS

#ifdef RDS_USE_BU1924
#ifdef RDS_BU1924_TWO_DET
/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
BYTE bReadRdsSync(void)large
{
	SetReadyRdsSyncIo();
	
	return(ReadRdsSyncIo());
}
#endif

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
BYTE bReadRdsClk(void)large
{
	SetReadyRdsClkIo();
	
	return(ReadRdsClkIo());
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
BYTE bReadRdsData(void)large
{
	SetReadyRdsDataIo();
	
	return(ReadRdsDataIo());  
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
void vReadRDSBU1924(void)large
{
	switch(*(_bRDSTimerState))
	{

		case RDS_GETTING_BIT_STATE:
			if(bReadRdsClk())
			{
				_rRDS.fgRDS_CLK=TRUE;
			}
			else
			{
				_rRDS.fgRDS_CLK=FALSE;
			}

			if( _rRDS.fgRDS_CLK == FALSE)
			{
				_rRDS.fgNextData = TRUE;
				return;
			}

			if(_rRDS.fgRDS_CLK &&  _rRDS.fgNextData)		//CLK为高时且只在上升沿后读数据线
			{
				_rRDS.fgNextData = FALSE;
				_rRDS.fgRDSBitData = (bReadRdsData() !=  0)?  TRUE:FALSE; 		    
				*(_bRDSTimerState)=RDS_PARSE_BIT_STATE;
			}     
		break;
		
		case RDS_PARSE_BIT_STATE:
			if(*(_bSequence) == 0x1b) break;
			_wSyndrome ^= ((_bRDS_data & 0x2000000) != 0)? 0x200 : 0; 
			_bRDS_data = (_bRDS_data << 0x1 & 0x3ffffff)+ _rRDS.fgRDSBitData; 
			_wSyndrome <<= 0x1; 
			_wSyndrome ^= ((_wSyndrome & 0x400) != 0)? 0x5b9 : 0;
			_wSyndrome ^= ((_bRDS_data & 0x1) != 0)? 0x31b : 0 ;
			_wSyndrome &= 0x3ff;
			*(_bRDSTimerState)=RDS_STORE_STATE;
		break;
		
		case RDS_STORE_STATE:
			switch(_wSyndrome)
			{
				case 0x3d8: // A 
					if(*(_bSequence) == 0xff)
					{
						*(_bSequence)  =  0; //*(_bSequence) <<2; 
						*(_pbGroupData+0)=0;// _bBuf[0] = 0;
						*(_pbGroupData+1) = (_bRDS_data >> 18) & 0xff;
						*(_pbGroupData+2)=  (_bRDS_data >> 10) & 0xff;
						_wSyndrome = 0;
						_bRDS_data = 0;
					}
				break;  

				case 0x3d4:// B
					if(*(_bSequence) == 0x0)
					{
						*(_bSequence)  = 0x01 ;//*(_bSequence) <<2 | 0x01;               
						*(_pbGroupData+3) = 0x20;
						*(_pbGroupData+4) = (_bRDS_data >> 18) & 0xff;
						*(_pbGroupData+5) =  (_bRDS_data >> 10) & 0xff;		
						_wSyndrome = 0;
						_bRDS_data = 0;
					}
				break;  

				case 0x25c:// C
					if(*(_bSequence) == 0x01)
					{
						*(_bSequence)  = 0x06;// *(_bSequence) <<2 | 0x02;                  		         
						*(_pbGroupData+6) = 0x40;
						*(_pbGroupData+7) = (_bRDS_data >> 18) & 0xff;
						*(_pbGroupData+8)=  (_bRDS_data >> 10) & 0xff;
						_wSyndrome = 0;
						_bRDS_data = 0;
					}
				break;  

				case 0x3cc:// C'
				break; 

				case 0x258:// D
					if(*(_bSequence) == 0x6)
					{
						*(_bSequence)  = 0x1b; //*(_bSequence) <<2 | 0x03;               
						*(_pbGroupData+9)= 0x60;
						*(_pbGroupData+10) = (_bRDS_data >> 18) & 0xff;
						*(_pbGroupData+11)=  (_bRDS_data >> 10) & 0xff;
						_wSyndrome = 0;
						_bRDS_data = 0;
					} 
				break; 

				default :
				break;
			}
			*(_bRDSTimerState)=RDS_GETTING_BIT_STATE;	

		break;

		default:
			*(_bRDSTimerState)=RDS_GETTING_BIT_STATE;
		break;
	}
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
void vRdsInforRefresh()large
{
	BYTE i;
	
	if(fgIsInTuner())
	{  
		if(*(_bSequence) == 0x1b)
		{ 
			for(i=0;i<12;i++)
			{
				//*(_pbGroupData+i)=_bBuf[i];
			}
			_rRDS.fgRDSBlkEnd=TRUE;
			*(_bSequence) = 0xff;
		}
		vRDSDetDeal();
	}
}
#endif

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
#ifndef TEMP_RDS
void vRDSInit(void)large
{
	#ifndef RDS_USE_BU1924
	//write the slave address to sa6588
	BYTE pbSend[3];
	pbSend[0]=0x20;//ox20
	pbSend[1]=0x20;//0x20
	pbSend[2]=0x2F;//0x6f
	fgRDSI2CDataWrite(3,pbSend); 
	#endif
	_bTimeCnt=0;
	//init the rds variable
	vResetRDSVar();
}
#endif

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
void vRDSSHOWCLR(void) large
{
	_bRDSAllStep=0;
	_bCurRDSStep=0;
	_bTimeCnt=100;//SIGN FF AS NOT SHOWN,
	_bRDSState=0;
	_vHasRDSINFO=FALSE;
	_vTempLoseRDS=TRUE;
	_VfdIsLighting=FALSE;
	//vVfdSymbol(VFD_SYM_A_CODE_RDS_OFF);
	RDSRECEIVESUM=0;
	_vHasRDSINFO=FALSE;
	_rRDS.fgRDSPS=FALSE;
	_rRDS.fgRDSCLK=FALSE;
	_rRDS.fgRDSPTN=FALSE;
	_rRDS.fgRDSPTY=FALSE;
	_rRDS.fgRDSRT=FALSE;
	_bTunerDispType=TUNER_DISP_NORMAL;
	_fgTunerDispReq=TRUE;
	_bChCount=0;
	_bVfdCounter = 2;

	#ifdef OSD_SHOW_RDS
	_wStartX = TUNER_BRW_MSG_START_X;
	_wStartY = TUNER_BRW_MSG_START_Y;
	_wEndX = TUNER_BRW_MSG_END_X;
	_wEndY = TUNER_BRW_MSG_END_Y;
	//vRectangle(WB_TUNER_MENU, 0, 0, TRUE, 0);	
	vRectangle(WB_TUNER_MENU, 0, 0, TRUE, TUNER_MENU_BG);
	#endif
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
void vRDSDispDeal(void)large
{      
	if(_vHasRDSINFO)
	{
		_bRDSState++;
		if(_bRDSState>=5) _bRDSState=0;
		
		if(_bRDSState==0)
		{
			vRDSSHOWCLR();
			_bIRKey=IR_NONE;  
			return;
		}
		
		_bTunerDispType=TUNER_DISP_RDS;
		vRDSNewDisCyc();
		if(_bRDSAllStep!=0)
		{
			_bCurRDSStep=0;
			_bTimeCnt=0;
		}
		else
		{
			//show the no RDS information of vfd
			vRDSSHOWCLR();
		}
	}
	_bIRKey=IR_NONE;
	return; 
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
BYTE  bRDSPSDispPrep(void)large
{
	BYTE i;
	
	if(!_rRDS.fgRDSPS)
	{
		return(0);
	}
	for(i=0;i<8;i++)
	{
		#ifdef RDS_USE_SM
		vSetSharedInfo(SI_RDS_DISPLAYDATA_ST_ADDR+i, bSharedInfo(SI_RDS_PS_NAME_ST_ADDR+i));
		#else
		*(_pbRDSDisplayData+i)=*(_pbRDSPsName+i);
		#endif
	}
	
	//return the all steps 
	return (KISENSE_VFD_LENTH+8);
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
BYTE  bRDSRTDispPrep(void) large
{
	BYTE i;

	if(!_rRDS.fgRDSRT)
	{
		return (0);
	}
	
	//prepare data for display
	for(i=0;i<64;i++)
	{
		#ifdef RDS_USE_SM
		vSetSharedInfo(SI_RDS_DISPLAYDATA_ST_ADDR+i, bSharedInfo(SI_RDS_RT_ST_ADDR+i));
		#else
		*(_pbRDSDisplayData+i)=*(_pbRDSRT+i);
		#endif
	}

	#ifdef RDS_USE_SM
	return(bSharedInfo(SI_RDS_RT_ST_ADDR+64));
	#else
	return(*(_pbRDSRT+64));
	#endif
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
code BYTE _bClockMsg[]={
0x4e,//N 0
0x4f,//O 1
0x57,//W 2
0X20,//_ 3
0X54,//T 4
0X49,//I 5
0X4D,//M 6
0X45,//E 7
0X20,//_ 8
0X49,//I 9
0X53,//S 10
0X20,//_ 11
};

#define RDS_CLOCK_MSG_LEN (sizeof(_bClockMsg))

BYTE  bRDSCLKDispPrep(void) large
{
	BYTE i,bHour,bMinute;
	BYTE bTemp;
	
	if(!_rRDS.fgRDSCLK)
	{
		return(0);
	}
	
	for(i=0;i<RDS_CLOCK_MSG_LEN;i++)
	{
		#ifdef RDS_USE_SM
		vSetSharedInfo(SI_RDS_DISPLAYDATA_ST_ADDR+i, _bClockMsg[i]);
		#else
		*(_pbRDSDisplayData+i)=_bClockMsg[i];
		#endif
		//now time is...
	}
	
	#ifdef RDS_USE_SM
	
	bHour=bSharedInfo(SI_RDS_CLK_ST_ADDR);
	bMinute=bSharedInfo(SI_RDS_CLK_ST_ADDR+1);
	vSetSharedInfo(SI_RDS_DISPLAYDATA_ST_ADDR+RDS_CLOCK_MSG_LEN,(bHour/10)+0x30);
	vSetSharedInfo(SI_RDS_DISPLAYDATA_ST_ADDR+RDS_CLOCK_MSG_LEN+1,(bHour%10)+0x30);
	vSetSharedInfo(SI_RDS_DISPLAYDATA_ST_ADDR+RDS_CLOCK_MSG_LEN+2,0x2d);
	vSetSharedInfo(SI_RDS_DISPLAYDATA_ST_ADDR+RDS_CLOCK_MSG_LEN+3,(bMinute/10)+0x30);
	vSetSharedInfo(SI_RDS_DISPLAYDATA_ST_ADDR+RDS_CLOCK_MSG_LEN+4,(bMinute%10)+0x30);
	vSetSharedInfo(SI_RDS_DISPLAYDATA_ST_ADDR+RDS_CLOCK_MSG_LEN+5,0x2e);
	#else
	bHour=*(_pbRDSCLK);
	bMinute=*(_pbRDSCLK+1);
	*(_pbRDSDisplayData+RDS_CLOCK_MSG_LEN)=(bHour/10)+0x30;
	*(_pbRDSDisplayData+RDS_CLOCK_MSG_LEN+1)=(bHour%10)+0x30;
	*(_pbRDSDisplayData+RDS_CLOCK_MSG_LEN+2)=0x2d;
	*(_pbRDSDisplayData+RDS_CLOCK_MSG_LEN+3)=(bMinute/10)+0x30;
	*(_pbRDSDisplayData+RDS_CLOCK_MSG_LEN+4)=(bMinute%10)+0x30;
	*(_pbRDSDisplayData+RDS_CLOCK_MSG_LEN+5)=0x2e; 
	#endif
	bTemp=((RDS_CLOCK_MSG_LEN+6)/KISENSE_VFD_LENTH)*KISENSE_VFD_LENTH;
	if((RDS_CLOCK_MSG_LEN+6)%KISENSE_VFD_LENTH)
	{
		bTemp+=KISENSE_VFD_LENTH+((RDS_CLOCK_MSG_LEN+6)%KISENSE_VFD_LENTH);
	}
	
	return(bTemp);
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
BYTE bRDSPTNDispPrep(void) large
{
	BYTE i;
	
	if(!_rRDS.fgRDSPTN)
	{
		return(0);
	}
	/*for(i=0;i<8;i++)
	{
		*(_pbRDSDisplayData+i)=*(_pbRDSPTN+i);
	}
	return(KISENSE_VFD_LENTH+8);
	*/
	return(0);
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
#define RDS_PTY_NS 24
#define RDS_PTY_NAME_NS 8

code BYTE _bRDSPTYList[RDS_PTY_NS][RDS_PTY_NAME_NS]={
{' ',' ','N','O','N','E',' ',' '},//NONE  0
{' ',' ','N','E','W','S',' ',' '},//NEWS 1
{' ',' ','I','N','F','O',' ',' '},//INFO   2
{' ','S','P','O','R','T',' ',' '},//SPORT  3
{' ',' ','T','A','L','K',' ',' '},//TALK   4
{' ','R','O','C','K',' ','M',' '},//ROCK M 5
{'C','L','S',' ','R','O','C','K'},//CLS ROCK 6
{'A','D','L','T',' ','H','I','T'},//7
{'S','O','F','T',' ','R','C','K'},//8
{'T','O','P',' ',' ',' ','4','0'},//9
{' ','C','O','U','N','T','R','Y'},//10
{' ','O','L','D','I','E','S',' '},//11
{' ','S',' ','O',' ','F',' ','T'},//12
{'N','O','S','T','A','L','G','A'},//13