tunerrds.c

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

			}      
		}

		if((_rRDS.wfgRdsSeg==GROUP_2_SEG)||(fgRTMsgEnd))
		{
			//set the flag of radio text 
			_rRDS.fgRDSRT=TRUE;
			//remember the char number 
			#ifdef RDS_USE_SM
			vSetSharedInfo(SI_RDS_RT_ST_ADDR+64, bRDSCharNum(fgGroupAB));
			#else
			*(_pbRDSRT+64)=bRDSCharNum(fgGroupAB);
			#endif
			return(TRUE);
		}
	} 

	return (FALSE);
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
BYTE bRDSCharNum(BOOL fgGroupAB)large
{
	BYTE i;
	WORD wShift=0x0001;
	BYTE bDisStep;
	BYTE bTemp;
	
	for(i=0;i<15;i++)
	{
		if(((_rRDS.wfgRdsSeg)&wShift)==0)
		{
			break;
		}
		wShift=wShift<<1;
	}

	if(i==15)
	{
		i++;
	}

	if(fgGroupAB)
	{
		//group 2b 
		bDisStep=KISENSE_VFD_LENTH*((i)*2/KISENSE_VFD_LENTH);
		bTemp=((i)*2)%KISENSE_VFD_LENTH;
		if(bTemp)
		{
			bDisStep+=KISENSE_VFD_LENTH+bTemp;
		}
	}
	else
	{
		//group 2a
		bDisStep=KISENSE_VFD_LENTH*((i)*4/KISENSE_VFD_LENTH);
		bTemp=((i)*4)%KISENSE_VFD_LENTH;
		if(bTemp)
		{
			bDisStep+=KISENSE_VFD_LENTH+bTemp;
		}
	}
	return(bDisStep);

}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
BOOL  fgParseRDSGroup4(void)large
{
	BYTE bHour,bMinute,boffset; 
	
	//check 4a or 4b flag
	if((*(_pbGroupData+4))&0x08)
	{
		//if 4b group no information to display then return false
		return(FALSE);
	}
	_rRDS.bRDSGrpIdSync=4;
	//get msb of hour 
	bHour=0;
	bHour=(*(_pbGroupData+8))&0x01;
	bHour=bHour<<4;
	bHour+=((*(_pbGroupData+10))&0xf0)>>4;
	//get minute value
	bMinute=0;
	bMinute=((*(_pbGroupData+10))&0x0f);
	bMinute=bMinute<<2;
	bMinute+=((*(_pbGroupData+11))&0xc0)>>6;
	//get offset value
	boffset=((*(_pbGroupData+11))&0x1f);
	//get the offset flag
	if((*(_pbGroupData+11))&0x20)
	{
		//flag 1 negative offset
		bHour-=(boffset>>1);//half an hour 
		if((boffset%2)!=0)
		{
			if(bMinute>=30)
			{
				bMinute-=30;
			}
			else
			{
				bMinute+=60;
				bMinute-=30;
				bHour--;
			}
		}
	}
	else
	{
		//flag 0 positive offset
		bHour+=(boffset>>1);//half an hour 
		if((boffset%2)!=0)
		{
			bMinute+=30;
			if(bMinute>=60)
			{
				bMinute-=60;
				bHour+=1;
			}
		}		
	}

	#ifdef RDS_USE_SM
	vSetSharedInfo(SI_RDS_CLK_ST_ADDR,bHour);
	vSetSharedInfo(SI_RDS_CLK_ST_ADDR+1,bMinute);
	#else
	*(_pbRDSCLK)=bHour;
	*(_pbRDSCLK+1)=bMinute;
	#endif
	_rRDS.fgRDSCLK=TRUE;

	return (TRUE);
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
/*
BOOL fgParseRDSGroupA(void)large
{
	BYTE bSegAddr;
	
	//check 10a or 10b flag
	if((*(_pbGroupData+4))&0x08)
	{
		//if 10b group no information to display then return false
		return(FALSE);
	}
	//get the address of segment
	bSegAddr=(*(_pbGroupData+5))&0x01;
	if(!_rRDS.fgRDSMsgSync)
	{
		if(bSegAddr==0)
		{
			_rRDS.fgRDSMsgSync=1;
			_rRDS.bRDSGrpIdSync=10;
		}
	}
	if(_rRDS.fgRDSMsgSync)
	{
		_rRDS.wfgRdsSeg=_rRDS.wfgRdsSeg|(1<<bSegAddr);
		*(_pbRDSPTN+bSegAddr*4)=*(_pbGroupData+7);
		*(_pbRDSPTN+bSegAddr*4+1)=*(_pbGroupData+8);
		*(_pbRDSPTN+bSegAddr*4+2)=*(_pbGroupData+10);
		*(_pbRDSPTN+bSegAddr*4+3)=*(_pbGroupData+11);
		if((_rRDS.wfgRdsSeg&0x0003)==GROUP_A_SEG)
		{
			_rRDS.fgRDSPTN=TRUE;	
			return (TRUE);
		}
	}

	return (FALSE);
}
*/

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
BOOL fgParseRDSGroupData(void)large
{
	BYTE bGroupId;
	BYTE bRet=FALSE;

	bGroupId=((*(_pbGroupData+4))&0xF0)>>4;
	//HOW THIS OPERATION CAN FIND GROUP2? 4*4=16
	//check the group information is processing group_id 
	if((bGroupId==0x04)||(bGroupId==0x0a))
	{
		vResetRDSMsgSync();
	}
	if(_rRDS.fgRDSMsgSync)
	{
		if(bGroupId!= _rRDS.bRDSGrpIdSync)//当前正在处理的类型
		{
			return(FALSE);
		}
	}

	switch(bGroupId)
	{
		case 0://group 0
			bRet=fgParseRDSGroup0();
		break;

		case 2://group 2
			bRet=fgParseRDSGroup2();
		break;

		case 4:
			bRet=fgParseRDSGroup4();
		break;

		//case 10:
		//	bRet=fgParseRDSGroupA();
		//break;
	}
	return(bRet);
}

#ifndef RDS_USE_BU1924
/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
BOOL fgReadRDSDAVN(void) large
{
	#ifdef TEMP_RDS
	return(FALSE);
	#else
	return(!ReadRdsDavnIo());
	#endif
}
#endif

#ifndef RDS_USE_BU1924
/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
BOOL fgRDSGroupSync(void)large
{
	//detect the group a 
	BYTE bBlkID;

	#ifdef RDS_USE_SM
	bBlkID=((bSharedInfo(SI_RDS_DATA_ST_ADDR))&0xe0)>>5;//NOT PROPER,MAYBE IS OX10
	#else
	bBlkID=((*(_pbRDSData))&0xe0)>>5;//NOT PROPER,MAYBE IS OX10
	#endif
	// bBlkID=((*(_pbRDSData))&0x10)>>4;//NOT PROPER,MAYBE IS OX10
	//START FROM THE BLOCK A
	if(bBlkID==0x00)
	{
		return(TRUE);
	}
	return(FALSE); 
}
#endif

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
void vExtractBlkFrmData(void)large
{
	BYTE bBlkId;

	#ifdef RDS_USE_SM
	bBlkId=((bSharedInfo(SI_RDS_DATA_ST_ADDR))&0xe0)>>5;
	#else
	bBlkId=((*(_pbRDSData))&0xe0)>>5;
	#endif
	if(bBlkId!=_rRDS.fgRDSStep)
	{
		_rRDS.fgRDSBlkSync=0;
		_rRDS.fgRDSBlkEnd=0;
		_rRDS.fgRDSStep=0;
		return;
	}
	#ifdef RDS_USE_SM
	*(_pbGroupData + _rRDS.fgRDSStep*3)= ((bSharedInfo(SI_RDS_DATA_ST_ADDR))&0xe0)>>5;
	//16 bit data
	*(_pbGroupData + _rRDS.fgRDSStep*3+1)=(bSharedInfo(SI_RDS_DATA_ST_ADDR+1));
	*(_pbGroupData + _rRDS.fgRDSStep*3+2)=(bSharedInfo(SI_RDS_DATA_ST_ADDR+2));
	#else
	*(_pbGroupData + _rRDS.fgRDSStep*3)=((*(_pbRDSData))& 0xe0)>>5;
	//16 bit data
	*(_pbGroupData + _rRDS.fgRDSStep*3+1)=(*(_pbRDSData+1));
	*(_pbGroupData + _rRDS.fgRDSStep*3+2)=(*(_pbRDSData+2));
	#endif
	_rRDS.fgRDSStep++;
	if(_rRDS.fgRDSStep>3)
	{
		_rRDS.fgRDSBlkEnd=1;
	}
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
//test 用1:ff的方式确定是否有rds信?
//正规方法应该参照rbds标准，对测试来讲，越大越好
void vRDSDetDeal(void) large
{
	#ifndef RDS_USE_BU1924
	#ifdef RDS_USE_SM
	BYTE i,pbRDSData[7];
	#endif
	
	if(fgReadRDSDAVN())
	#endif
	{   	
		_vTempLoseRDS=FALSE;
		RDSRECEIVESUM=0;
		#ifndef RDS_USE_BU1924
		if(!_rRDS.fgRDSBlkSync)//deal with blocka
		{    
			#ifdef RDS_USE_SM
			fgRDSI2CDataRead(7,(pbRDSData));
			for(i=0;i<7;i++)
			{
				vSetSharedInfo(SI_RDS_DATA_ST_ADDR + i, pbRDSData[i]);
			}
			#else
			fgRDSI2CDataRead(7,(_pbRDSData));
			#endif
			//analcy the data find block a ID
			_rRDS.fgRDSBlkSync=fgRDSGroupSync();
			_rRDS.fgRDSStep=0;
			if(_rRDS.fgRDSBlkSync)
			{
				vExtractBlkFrmData();
			}

		}
		else if(!_rRDS.fgRDSBlkEnd)
		{ 
			#ifdef RDS_USE_SM
			fgRDSI2CDataRead(7,(pbRDSData));
			for(i=0;i<7;i++)
			{
				vSetSharedInfo(SI_RDS_DATA_ST_ADDR + i, pbRDSData[i]);
			}
			#else
			fgRDSI2CDataRead(7,(_pbRDSData));
			#endif
			vExtractBlkFrmData();
		}
		#endif
		if(_rRDS.fgRDSBlkEnd)//A GROUP IS absoluteLY RECEIVED
		{
			//parse the data get the data to display

		if(fgParseRDSGroupData())
		{
			_vHasRDSINFO=TRUE;
			vResetRDSMsgSync();
		}
		vResetRDSBlkSync();
		}
	}
	#if 0//Terry fgReadRDSDAVN
	else
	{ 
		RDSRECEIVESUM++;
		if(RDSRECEIVESUM == 0xff)
		{
			RDSRECEIVESUM=0;
			_vTempLoseRDS=TRUE;
		}
	}
	#endif
}

/***************************************************************************************
    Function : 
    Description : 
    Parameter : 
    Return    : 
***************************************************************************************/
void vTunerRdsInit(void) large
{
	BYTE bTmp;	

	#ifdef RDS_USE_BU1924
	for(bTmp=0;bTmp<7;bTmp++)		//初次上电时RDS乱显，清除RDS显示内容
	{
		#ifdef RDS_USE_SM
		vSetSharedInfo(SI_RDS_DATA_ST_ADDR + bTmp, 0);
		#else
		*(_pbRDSData+bTmp)=0;
		#endif
	}
	#endif

	_bTunerDispType = TUNER_DISP_NORMAL;

	#ifdef RDS_USE_BU1924
	MEnableTimer1();
	MTrgTimer1Cnt();
	#endif
	#ifndef TEMP_RDS
	vRDSInit();
	#endif

	_bRDSState = 0;
}

void vTunerRdsPro(void) large
{   
	#ifdef RDS_BU1924_NEW_TIMER
	switch (_bTunerDispType)
	{
		case TUNER_DISP_RDS:
			if((_bTimeCnt==0)&&(_bVfdCounter==0))
			{
				vRDSDispProc();					
			}          
		break;
		
		default:
		break;
	}
	#endif

	if((_bTunerDispType == TUNER_DISP_NORMAL)&&(_bVfdCounter == 0)) 
	{								
		#ifndef RDS_BU1924_NEW_TIMER			
		vRDSDetDeal();
		#endif
		//LET IT SHOW AUTO AFTER 2 SECOND
		if(_vHasRDSINFO&&!_bRDSState)
		{
			_bTimeCnt=100;
			vRDSDispDeal();
		}
		
		if(_vTempLoseRDS)
		{
			if(_bTunerDispType==TUNER_DISP_RDS)
			{
				vRDSSHOWCLR();
			}
		}
	}
}

#endif