{
				NextDerotStep--;
			}
		
			if (NextDerotStep)
			{
				FieldSetVal(handle, DEROTATORFREQUENCYMSB, (INT16)MSB(DerotFreq));
				FieldSetVal(handle, DEROTATORFREQUENCYLSB, (INT16)LSB(DerotFreq));   
				RegSetRegisters(handle, R_CFRM, 2);			/*	Set the derotator frequency	*/
			}
		}
	
		pParams->Direction = -pParams->Direction;			/*	Change the zigzag direction	*/    
	}
	while ((pParams->State != TIMINGOK) && NextDerotStep);
	
	if (pParams->State == TIMINGOK)
	{
		RegGetRegisters(handle, R_CFRM, 2);					/*	Get the derotator frequency	*/ 
		pParams->DerotFreq = pParams->TunerIQ*((short int) MAKEWORD(FieldGetVal(handle,DEROTATORFREQUENCYMSB),FieldGetVal(handle,DEROTATORFREQUENCYLSB)));
		pResult->SymbolRate = RegGetSymbolRate(handle);
	}
	
	return pParams->State;
}

/*****************************************************
--FUNCTION	::	SearchCarrier
--ACTION	::	Search a QPSK carrier with the derotator
--PARAMS IN	::	
--PARAMS OUT::	NONE
--RETURN	::	NOCARRIER if no carrier had been found, CARRIEROK otherwise 
--***************************************************/
SIGNALTYPE SearchCarrier(DEMOD_HANDLE handle, SEARCHPARAMS *pParams, SEARCHRESULT *pResult)
{
	long DerotFreq = 0;
	long LastDerotFreq = 0;
	long DerotLimit;
	long NextLoop = 3;
	INT32 index = 0;

	pParams->State = NOCARRIER;

	DerotLimit = (pParams->SubRange / 2L) / pParams->Mclk;
	DerotFreq = pParams->DerotFreq;
	
	RegSetField(handle, CFD_ALGO, 1);
	
	do
	{	
		if (CheckCarrier(handle, pParams) == NOCARRIER)
		{
			index++;
			LastDerotFreq = DerotFreq;
			DerotFreq += index*pParams->Direction*pParams->TunerIQ*pParams->DerotStep;	/*	Compute the next derotator position for the zig zag	*/    
		
			if (ABS(DerotFreq) > DerotLimit)
			{
				NextLoop--;
			}
				
			if (NextLoop)
			{
				RegSetField(handle,CFD_ALGO, 1);
				FieldSetVal(handle,DEROTATORFREQUENCYMSB,(INT16)MSB(DerotFreq));
				FieldSetVal(handle,DEROTATORFREQUENCYLSB,(INT16)LSB(DerotFreq));   
				RegSetRegisters(handle,R_CFRM, 2); 			/*	Set the derotator frequency	*/
			}
		}
		else
		{
			pResult->SymbolRate = pParams->SymbolRate;
		}
		
		pParams->Direction = -pParams->Direction;			/*	Change the zigzag direction	*/    
	}
	while ((pParams->State != CARRIEROK) && NextLoop);
	
	
	if (pParams->State == CARRIEROK)
	{
		pParams->DerotFreq = DerotFreq;
	}
	else
	{
		pParams->DerotFreq = LastDerotFreq;	
	}
	
	return pParams->State;
}


/****************************************************
--FUNCTION	::	SearchLock
--ACTION	::	Search for lock indicator
--PARAMS IN	::	pParams->Tdata	=>	Time to wait for data
--PARAMS OUT::	pParams->State	=>	Result of the search
--RETURN	::	NODATA if data not founded, DATAOK otherwise 
--**************************************************/
#pragma argsused
SIGNALTYPE SearchLock(DEMOD_HANDLE handle, SEARCHPARAMS *pParams, SEARCHRESULT *pResult)
{
	if (CheckData(handle, pParams) == NODATA)		/* Check for data */   
	{
		IQInvertion(handle);						/* Invert I and Q */
		if (CheckData(handle, pParams) == NODATA)	/* Check for data */
			IQInvertion(handle);					/* Invert I and Q */ 
	}

	return pParams->State;
}

/*****************************************************
--FUNCTION	::	SearchData
--ACTION	::	Search a QPSK carrier with the derotator, if there is a false lock 
--PARAMS IN	::	
--PARAMS OUT::	NONE
--RETURN	::	NOCARRIER if no carrier had been found, CARRIEROK otherwise 
--***************************************************/
SIGNALTYPE SearchData(DEMOD_HANDLE handle, SEARCHPARAMS *pParams, SEARCHRESULT *pResult)
{
	long DerotFreq;
	long DerotStep;
	long DerotLimit;
	long DerotOffset;
	INT32 NextLoop = 3;
	INT32 index = 1;
	long CurrentFreq;
	
	CurrentFreq = pParams->Frequency;
	DerotStep = (pParams->SymbolRate/4L)/pParams->Mclk; 
	DerotLimit = (pParams->SubRange/2L)/pParams->Mclk;      
	DerotFreq = pParams->DerotFreq;
	
	do
	{
		if ((pParams->State != CARRIEROK) || (SearchLock(handle,pParams,pResult) != DATAOK))
		{
			/* Compute the next derotator position for the zig zag	*/
			DerotFreq += index*pParams->Direction*pParams->TunerIQ*DerotStep;
			CurrentFreq = pParams->Frequency + (DerotFreq*pParams->Mclk)/1000;
		
			if (ABS(DerotFreq) > DerotLimit)
			{
				NextLoop--;
			}
			
			if (NextLoop)
			{	
				/* If the False Lock is outside the derotator capture range	*/
				DerotOffset = ((CurrentFreq - (TunerSetFrequency(handle,CurrentFreq))) * pParams->Mclk )/1000; /* Move the tuner */
				WaitTuner(handle, 100);									/* Is tuner Locked? */ 
			
				RegSetField(handle, CFD_ALGO, 1);
			
				FieldSetVal(handle, DEROTATORFREQUENCYMSB, (INT16)MSB(DerotOffset));
				FieldSetVal(handle, DEROTATORFREQUENCYLSB, (INT16)LSB(DerotOffset)); 
				RegSetRegisters(handle, R_CFRM, 2);  /*	Reset the derotator frequency */
				
				CheckCarrier(handle, pParams);
				
				index++;
			}
		}
		
		pParams->Direction = -pParams->Direction;			/* Change the zigzag direction */
	}
	while ((pParams->State != DATAOK) && NextLoop);
	
	if (pParams->State == DATAOK)
	{
		/* Get the derotator frequency	*/
		pParams->DerotFreq = pParams->TunerIQ*(INT32)(MAKEWORD(FieldGetVal(handle,DEROTATORFREQUENCYMSB),FieldGetVal(handle,DEROTATORFREQUENCYLSB)));
		pParams->Frequency = CurrentFreq;
	}	

	return pParams->State;
}


/****************************************************
--FUNCTION	::	CheckRange
--ACTION	::	Check if the founded frequency is in the correct range
--PARAMS IN	::	pParams->BaseFreq =>	
--PARAMS OUT::	pParams->State	=>	Result of the check
--RETURN	::	RANGEOK if check success, OUTOFRANGE otherwise 
--***************************************************/
#pragma argsused
SIGNALTYPE CheckRange(SEARCHPARAMS *pParams, SEARCHRESULT *pResult) 
{
	INT32 RangeOffset;
	INT32 TransponderFrequency;

	RangeOffset = pParams->SearchRange / 2000L;  
	TransponderFrequency = pParams->Frequency + (pParams->DerotFreq * pParams->Mclk) / 1000L;
	
	if ( (TransponderFrequency >= (pParams->BaseFreq - RangeOffset) )
		 && (TransponderFrequency <= (pParams->BaseFreq + RangeOffset)) )
	{
		pParams->State = RANGEOK;
	}
	else
	{
		pParams->State = OUTOFRANGE;
	}

	return pParams->State;
}

/****************************************************
--FUNCTION	::	TunerCentering
--ACTION	::	Optimisation of the tuner position to allow frequency variations
--PARAMS IN	::	pParams	
				AllowedOffset
--PARAMS OUT::	pResult
--RETURN	::	DATAOK if success 
--**************************************************/
SIGNALTYPE TunerCentering(DEMOD_HANDLE handle, SEARCHPARAMS *pParams, SEARCHRESULT *pResult, long AllowedOffset)    
{
	INT32 DerotFreq;
	INT32 MinOffset;
	INT32 MaxOffset;
	INT32 CentringFrequency;
	INT32 TransponderFrequency;
	INT32 Fs;
	INT32 sign;
	
	Fs = CarrierWidth(pParams->SymbolRate, pParams->RollOff);
	DerotFreq = ABS(pParams->DerotFreq * pParams->Mclk); 
	
	if ((pParams->TunerIF == 0) && (Fs < 4000000L))
	{
		MinOffset = 2000000L;
	}
	else
	{
		MinOffset = 0;
	}
	
	MaxOffset = MAX(pParams->TunerBW/2 - Fs/2 - AllowedOffset, MinOffset + pParams->TunerStep);   
	
	if (!INRANGE(MinOffset, DerotFreq, MaxOffset) || (CheckData(handle, pParams) == NODATA))
	{
		sign = (pParams->DerotFreq > 0) ? 1 : -1; 
		TransponderFrequency = pParams->Frequency + (pParams->DerotFreq * pParams->Mclk) / 1000;
		CentringFrequency = TransponderFrequency + (sign * MinOffset) / 1000;
	
		CentringFrequency = TunerSetFrequency(handle, CentringFrequency);	/*	Move the tuner	*/   
		WaitTuner(handle, 100);		/* Is tuner Locked? (wait 100 ms maxi) */     
	
		/* Reset Derotator */
		pParams->DerotFreq = pParams->TunerIQ*(((TransponderFrequency - CentringFrequency)*1000L)/pParams->Mclk);
		pParams->Frequency = CentringFrequency;
		pParams->Direction = 1;
		FieldSetVal(handle, DEROTATORFREQUENCYMSB, MSB(pParams->DerotFreq));
		FieldSetVal(handle, DEROTATORFREQUENCYLSB, LSB(pParams->DerotFreq));   
		RegSetRegisters(handle, R_CFRM, 2);
		
		/* Wait for agc1, agc2 and timing loop */
		Ker_SleepUs(1000UL * pParams->Tagc1 + pParams->Tagc2 + pParams->Ttiming);	
	
		/* Search for carrier */
		if (SearchCarrier(handle, pParams, pResult) == CARRIEROK)
		{
			/* Search for data */
			SearchData(handle, pParams, pResult);
		}
	}
	
	return pParams->State;
}

/****************************************************
--FUNCTION	::	FirstSubRange
--ACTION	::	Compute the first SubRange of the search 
--PARAMS IN	::	pParams->SearchRange
--PARAMS OUT::	pParams->SubRange
--RETURN	::	NONE
--***************************************************/
void FirstSubRange(SEARCHPARAMS *pParams)
{
	long maxsubrange;
	
	maxsubrange = pParams->TunerBW - CarrierWidth(pParams->SymbolRate,pParams->RollOff)/2;
	
	if (maxsubrange > 0)
	{
		pParams->SubRange = MIN(pParams->SearchRange,maxsubrange);
	}
	else
	{
		pParams->SubRange = 0;
	}

	pParams->Frequency = pParams->BaseFreq;
	pParams->TunerOffset = 0L;
	pParams->SubDir = 1;
}
  
/****************************************************
--FUNCTION	::	NextSubRange
--ACTION	::	Compute the next SubRange of the search 
--PARAMS IN	::	Frequency	->	Start frequency
--				pParams->SearchRange
--PARAMS OUT::	pParams->SubRange
--RETURN	::	NONE
--***************************************************/
void NextSubRange(SEARCHPARAMS *pParams)
{
	long OldSubRange;
	
	if (pParams->SubDir > 0)
	{
		OldSubRange = pParams->SubRange;
		pParams->SubRange = MIN((pParams->SearchRange/2) - (pParams->TunerOffset + pParams->SubRange/2),pParams->SubRange);
		pParams->TunerOffset += (OldSubRange + pParams->SubRange)/2;
	}
	
	pParams->Frequency = pParams->BaseFreq + (pParams->SubDir * pParams->TunerOffset)/1000;    
	pParams->SubDir = -pParams->SubDir;
}

/*****************************************************
--FUNCTION	::	AutoSearchAlgo
--ACTION	::	Search for Signal, Timing, Carrier and then data at a given Frequency, 
--				in a given range
--PARAMS IN	::	NONE
--PARAMS OUT::	NONE
--RETURN	::	Type of the founded signal (if any)
--***************************************************/
SIGNALTYPE AutoSearchAlgo(DEMOD_HANDLE handle)
{
	UINT8 sn, to, hy, errorrate;

	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;			

	SEARCHPARAMS *pParams;
	SEARCHRESULT *pResult;
	
	pParams = &(sDemodData->Params);
	pResult = &(sDemodData->Result);
	
	pParams->Frequency = pParams->BaseFreq;
	pParams->Direction = 1;
	
	RegTriggerOn(handle);
	RegSetSymbolRate(handle,pParams->SymbolRate);	/*	Set the symbol rate	*/
	RegGetOneRegister(handle,R_PR);
	RegGetOneRegister(handle,R_VSEARCH);  
	
	/* Get fields value	*/
	sn = FieldGetVal(handle,SN);  
	to = FieldGetVal(handle,TO);  
	hy = FieldGetVal(handle,H);  
	errorrate = FieldGetVal(handle,RATE);
	RegTriggerOff(handle);
	
	/* Initial calculations	*/
	RegTriggerOn(handle);
	pParams->DerotStep = pParams->DerotPercent*(pParams->SymbolRate/1000L)/pParams->Mclk;	/*	saut de DerotStep/1000 * Fsymbol	*/     
	pParams->Ttiming = CalcTimingTimeConstant(pParams->SymbolRate);
	pParams->Tderot = 2L + CalcDerotTimeConstant(pParams->SymbolRate);
	pParams->Tdata = 2L + CalcDataTimeConstant(handle,errorrate,sn,to,hy,pParams->SymbolRate);
	RegTriggerOff(handle);
	
	FirstSubRange(pParams);
	
	do
	{
		/* Handle any exceptions - abort */
		if (Exception_catchAndRethrow(EXCEPTION_MEDIUM_EJECTED | EXCEPTION_POWER_DOWN_REQUEST | EXCEPTION_ABORT_FTA_CH_PLAY | EXCEPTION_ABORT_FTA_SCAN)) 
		{
			sDemodData->Result.SignalType = NOAGC1;

			tr_printf(("AutoSearchAlgo: Exception_catchAndRethrow()\n"));

			return FALSE;
		}

		/* Initialisations	*/
		FieldSetVal(handle, DEROTATORFREQUENCYMSB, 0); 
		FieldSetVal(handle, DEROTATORFREQUENCYLSB, 0);   
		RegSetRegisters(handle, R_CFRM, 2); 		/* Reset of the derotator frequency */
		RegSetField(handle, RTF, 0);
		RegSetField(handle, CFD_ALGO, 1);
	
		pParams->DerotFreq = 0;
		pParams->State = NOAGC1;
		
		RegTriggerOn(handle);
		pParams->Frequency = TunerSetFrequency(handle, pParams->Frequency);	/*	Move the tuner	*/ 
		RegTriggerOff(handle);
		
		/* Temporisations */
		RegTriggerOn(handle);
		Ker_SleepUs(1000UL * pParams->Tagc1 + pParams->Tagc2 + pParams->Ttiming);	/* Wait for agc1,agc2 and timing loop */
		WaitTuner(handle, 100L);		/*	Is tuner Locked	? (wait 100 ms maxi) */
		RegTriggerOff(handle);
		
		RegTriggerOn(handle);
		
		if (CheckAgc1(handle,pParams) >= AGC1SATURATION)
		{
			/* There is signal in the band */
			if (pParams->SymbolRate <= pParams->TunerBW/2)
			{
				/* For low rates (SCPC)	*/
				SearchTiming(handle, pParams, pResult);
			}
			else
			{
				/* For high rates (MCPC) */
				CheckTiming(handle,pParams);
			}

			if (pParams->State != NOTIMING)
			{
				/* Search for carrier */
				if (SearchCarrier(handle, pParams, pResult) == CARRIEROK)
				{
					/* Check for data */
					if (SearchData(handle, pParams, pResult) == DATAOK)
					{
						if (pParams->ScanMode != DRV_SCAN)
						{
							TunerCentering(handle, pParams, pResult, 2000000L);
						}

						if (CheckRange(pParams, pResult) == RANGEOK)
						{
							pResult->Frequency = pParams->Frequency + (pParams->DerotFreq*(pParams->Mclk)/1000); 
							pResult->PunctureRate = RegGetField(handle, CPR); 							
						}
					}
				}
			}
		}
		
		if (pParams->State != RANGEOK)
		{
			NextSubRange(pParams);
		}
		
		RegTriggerOff(handle);
	}	  
	while (pParams->SubRange && (pParams->State != RANGEOK));
	
	pResult->SignalType = pParams->State;
	
	return pParams->State;
}

/*****************************************************
--FUNCTION	::	SimpleSearch
--ACTION	::	only set parameters and Search for Signal
--PARAMS IN	::	NONE
--PARAMS OUT::	NONE
--RETURN	::	Type of the founded signal (if any)
--***************************************************/
SIGNALTYPE SimpleSearch(DEMOD_HANDLE handle)
{
	UINT8 errorrate,sn,to,hy;
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;			

	SEARCHPARAMS *pParams;
	SEARCHRESULT *pResult;
	
	pParams = &(sDemodData->Params);
	pResult = &(sDemodData->Result);
	
	pParams->Frequency = pParams->BaseFreq;
	pParams->Direction = 1;
	
	RegTriggerOn(handle);
	RegSetSymbolRate(handle,pParams->SymbolRate);	/*	Set the symbol rate	*/
	RegGetOneRegister(handle,R_PR);
	RegGetOneRegister(handle,R_VSEARCH);  
	
	/* Get fields value	*/