radio.c

LV24000的单片机DEMO程序

	// FM regions
	g_wFreqGrid = 10;	// Default: 100 kHz FM frequency grid for Japan/USA (in 10 kHz unit)
	switch (byRegion)
	{
	case REGION_NONE:	// No region - use hardware limit
		g_wDisplayBandLow = RfToDisplayFreq(g_wHwRfLow);
		g_wDisplayBandHigh = RfToDisplayFreq(g_wHwRfHigh);
		break;

	case REGION_JAPAN:	// Japan FM band
	case REGION_JAPAN_WIDE:	// Japan FM band
		SetDeemphasis(DEEMP_50);
		g_wDisplayBandLow  = 7600;		// Japan lower limit: 76 MHz
		g_wDisplayBandHigh = 9000;		// Japan upper limit: 90 MHz
		if (byRegion == REGION_JAPAN_WIDE)
			g_wDisplayBandHigh = 10775;	// Japan wide upper limit: 107.75 MHz
		break;

	case REGION_US:		// US FM band
		SetDeemphasis(DEEMP_75);
		g_wDisplayBandLow  = 8750;		// Europe lower limit: 87.5 MHz
		g_wDisplayBandHigh = 10800;		// Europe upper limit: 108 MHz
		break;

	//case REGION_EUROPE:	// Use Europe FM band as default
	default:
		byRegion = REGION_EUROPE;		// Make sure byRegion is valid
		SetDeemphasis(DEEMP_50);
		g_wDisplayBandLow  = 8750;		// Europe lower limit: 87.5 MHz
		g_wDisplayBandHigh = 10800;		// Europe upper limit: 108 MHz
		g_wFreqGrid = 5;			// Europe FM grid is 50 kHz (in 10 kHz unit)
		break;
	}
	// Update current region
	 g_byRegion = byRegion;
	return(LVLS_NO_ERROR);
} // End SetRegion

/* ************************************************************************************************
 *
 *  Function:   ScanStation
 *
 *  Authors:    Hung van Le
 *  Purpose:    Search for FM station
 *  Input:      byFlag: flag to control the scan:
 *			SCANSTN_DIR: scan direction
 *				      1 => scan up (increase frequency).
 *				      0 => scan down (decrease frequency)
 *			SCANSTN_AUTO: 1=> Auto scan: scan whole band in specified direction with fieldstrength in g_byScanLevel
 *						     Return found station via callback with reason CBRN_ASCAN_FOUND
 *			              0=> Search for next/previous station with fieldstrength in g_byScanLevel
 *  Output:     Status as defined in LvErr.h
 *  Global:	g_byStnFlag:
 *			STN_VALID (W): clear when the scan starts, after the scan it reflects the valid station
 *		g_wDisplayBandLow (RO): start frequency for the scan when wBeginFreq is 0
 *		g_wDisplayBandHigh (RO): end frequency for the scan when wEndFreq is 0
 *		g_byScanLevel: field strength level to accept/reject a station (must be set before enter this function)
 *			
 *  Comments:   The scan will be aborted when the callback function reports any error. So host can abort the scan by returning 
 *		error with the call back (out of storage for auto scan, user abort...)
 *
 * ************************************************************************************************
 * Copyright (c) 2004. Semiconductor Ideas to the Market (ItoM) B.V. All rights reserved.
 * ************************************************************************************************ */
BYTE ScanStation(BYTE byFlag)
{
	BYTE byResult;
	BOOL bOrgAudioMute, bOrgAudioMode; //, bOrgAgcSpeed;
	BOOL bDone;
	BYTE byStationFound;
	int  iDir;
	WORD wCfg;
	WORD wBeginFreq, wEndFreq, wOrgFreq;
	WORD wRfLimitLo, wRfLimitHi;

	// Scan direction
	if (byFlag & SCANSTN_DIR)
		iDir = 1;		// Scan up
	else
		iDir = -1;		// Scan down

	// Convert band limit to RF limt
	wRfLimitLo = DisplayFreqToRf(g_wDisplayBandLow) - g_wFreqGrid;	// Convert display to RF frequency (1 grid extra)
	wRfLimitHi = DisplayFreqToRf(g_wDisplayBandHigh) + g_wFreqGrid; // Convert display to RF frequency (1 grid extra)

	// Initialize the scan limits according to scan mode
	wOrgFreq = 0;	// To avoid compiler warning W303 (uninitialized var.)
	if (byFlag & SCANSTN_AUTO)	// Auto search 
	{
		wBeginFreq = wRfLimitLo;
		wEndFreq = wRfLimitHi;
		// Determine start frequency
		if (iDir>0)
			g_wLastSetRF = wBeginFreq; 	// Scan up - start from lower limit
		else
			g_wLastSetRF = wEndFreq;	// Scan down - start from upper limit
		g_byStnFlag &= (~STN_VALID);	 	// No valid station
	}
	else // Search next mode
	{
		// Make sure we have a valid current frequency
		CheckRfLimit(&g_wLastSetRF, wRfLimitLo, wRfLimitHi, iDir);
		wOrgFreq = g_wLastSetRF; // This is our start frequency
		
		// Determine scan boundary
		if (iDir>0)	// Scan up
		{
			// Scan up from current frequency to upper limit
			wBeginFreq = g_wLastSetRF; // start at current frequency
			wEndFreq = wRfLimitHi;

			// Adjust the start frequency in special case
			if (wOrgFreq == wRfLimitHi) 	// Scanning up starting at high limit
				wOrgFreq++;
		}
		else		// Scan down
		{
			// Scan down from current frequency to lower limit
			wBeginFreq = wRfLimitLo;
			wEndFreq = g_wLastSetRF;

			// Adjust the start frequency in special case
			if (wOrgFreq == wRfLimitLo) 	// Scanning up starting at high limit
				wOrgFreq--;
		}
	}
		
	// Select correct oscillator output and enable measuring mode
	wCfg = SetUpChipMode(CO_RF_OSC|CHIP_MEASURE_MODE|CHIP_AFC_OFF);

	// Prepare the chip for scanning
	bOrgAudioMute = SetChipAudioMute(TRUE, MUTESRC_OPERATION);		// Mute audio
	// @@@ Speed up AGC for faster field strength measurement: already enabled by default
	// bOrgAgcSpeed = DriveBit(IR01_RADIO_CTRL2_REG, IR1_RCTL2_AGC_SPD, TRUE);
		
	// Force mono mode before scanning
	bOrgAudioMode = SetChipStereo(FALSE);

	// Perform scan
	byStationFound = 0;
	bDone = FALSE;
	while (!bDone)
	{
	#ifdef SUPPORT_AMFM
		if ( (g_byStnFlag & STN_AM_MODE) == STN_AM_MODE )
			byResult = ScanAmRoutine(iDir, wBeginFreq, wEndFreq);
		else
			byResult = ScanFmRoutine(iDir, wBeginFreq, wEndFreq);
	#endif // SUPPORT_AMFM
	#ifdef FM_ONLY
		byResult = ScanFmRoutine(iDir, wBeginFreq, wEndFreq);
	#endif //FM_ONLY
		if (byResult==LVLS_NO_ERROR)
		{
			// Save the found station if auto scan mode
			if (byFlag & SCANSTN_AUTO)	// Auto search 
			{
				byStationFound++;
				byResult = CallBack(CRSN_ASCAN_FOUND);
				if (byResult != LVLS_NO_ERROR)
					bDone = TRUE;
			}
			else	// Normal scan mode
			{
				bDone = TRUE;	// Just scan once
					
				//if (m_bValidStation)
				//	FineTuneFmToIF(&m_bValidStation);
			}
		}
		else if (byResult == LVLS_RFFREQ_ENDOFBAND_ERR)	// End of band reached
		{
			if (byFlag & SCANSTN_AUTO)	// Auto scan mode 
			{
				bDone = TRUE;		// Done when end of band reached
			}
			else // Search mode
			{
				switch (g_byStnFlag & STN_WRAP_MODE)
				{
				case STNWRAP_NONE:	// No wrapping - terminate with end of band error
					bDone = TRUE;
					break;
					
				case STNWRAP_CONT:	// Continue wrapping - repeat the search at boundary
					wBeginFreq = wRfLimitLo;
					wEndFreq = wRfLimitHi;
					if (iDir>0)	// Scan up
						g_wLastSetRF = wBeginFreq;
					else		// Scan down
						g_wLastSetRF = wEndFreq;
					break;

				case STNWRAP_ONCE:	// Repeat the search until the start frequency reached again
					if (iDir>0)	// Scan up
					{
						if (g_wLastSetRF <= wOrgFreq)
						{
							byResult = LVLS_NO_STATION_FOUND_ERR;
							bDone = TRUE;
						}
						else
						{
							wBeginFreq = wRfLimitLo;
							wEndFreq = wOrgFreq;
							g_wLastSetRF = wBeginFreq;
						}
					}
					else		// Scan down
					{
						if (g_wLastSetRF >= wOrgFreq)
						{
							byResult = LVLS_NO_STATION_FOUND_ERR;
							bDone = TRUE;
						}
						else
						{
							wBeginFreq = wOrgFreq;
							wEndFreq = wRfLimitHi;
							g_wLastSetRF = wEndFreq;
						}
					}
					break;
				} // EndSwitch
			} // EndElse byFlag & SCANSTN_AUTO
		} // EndElseIf (byResult == LVLS_RFFREQ_ENDOFBAND_ERR
		else	// Other error - terminate
		{
			bDone = TRUE;
		}
	} // EndWhile
		
#ifdef USE_PRESET
	// Set last found station (only in auto scan mode)
	if (byStationFound > 0)
	{
		SetFrequency(RecallPreset(byStationFound-1));
	}
#endif //USE_PRESET

	// Restore chip config
	SetChipStereo(bOrgAudioMode);
	//@@@ DriveBit(IR01_RADIO_CTRL2_REG, IR1_RCTL2_AGC_SPD, bOrgAgcSpeed); //@@@ Restore AGC speed state
	SetChipAudioMute(bOrgAudioMute, MUTESRC_OPERATION);
	SetUpChipMode(wCfg);

	// Report the final status via callback
	CallBack(CRSN_STN_CHNG);
	return(byResult);
} // End ScanStation