sn15test.c

ST5100 driver files for ST chipset

	SSnimConfig SnimCreateStruct;
	/*  */
	VK_SEM_Create(&aaa); //   20050826
	
	printSn15(("Snim_Drv_Initailise ++\n\r"));
	g_ClocksPerMilllisecond = VK_TIMER_GetTickFreq() / 1000;

	g_isPortOpen = TRUE;//TestsnimOpenPort(g_strPort);
	SnimCreateStruct.pfEnable = TestsnimE;/* No Sleep Function */
	SnimCreateStruct.pfRegRead = TestsnimRR;
	SnimCreateStruct.pfRegWrite =TestsnimRW;
	SnimCreateStruct.pfSlaveAccess = TestsnimSA;
	SnimCreateStruct.pfnDiSEqCCallBack = TestsnimDiSEqCCallBack;
	SnimCreateStruct.ucAddress = SNIM_DEFAULT_ADDRESS;
	SnimCreateStruct.ucEnableNo = SNIM_DEFAULT_ENABLENO;
	SnimCreateStruct.wConfig = SNIM_DEFAULT_WCONFIG;
	g_hTheSnim = SnimCreate(unitId, &SnimCreateStruct);
	if (!g_hTheSnim)
	{
		printSn15(("[Snim_Drv_Initailise] Error !!! \n\r"));

		return 1; 
	}

	((PSSNIMCTL)g_hTheSnim)->Channel.MHz = 0;//1150;
	((PSSNIMCTL)g_hTheSnim)->Channel.kRs = 0;//28125;
	((PSSNIMCTL)g_hTheSnim)->Channel.ucExt = ( 0 & SCHANNELEXT_CODERATE);
	((PSSNIMCTL)g_hTheSnim)->wDebugFlags = 0;

	lnb.HiBandLO=10600;//Universal LNB 1
	lnb.LoBandLO=9750;
	lnb.LoHiSwap=11700;
	lnb.Delay_ms = 10;
	
	SnimSetLnb(g_hTheSnim,&lnb);
	
	SnimCommand(g_hTheSnim,SNIM_COMMAND_POWER_ON);//READY STATE
	
	printSn15(("Snim_Drv_Initailise --\n\r"));
}


unsigned char Snim_Drv_IsTunerLocked(void)
{
   		Sint32T AcquisitionResult;
		printSn15((">>> FE_DRV_main : SNIM_DRV_CHECK_LOCK !!!\n\r"));
		AcquisitionResult = SnimRead(g_hTheSnim, SNIM_DATA_DEMODSTATE); //READ 
		if (AcquisitionResult == SNIM_STATE_LOCKED)
		{
			printSn15(("FE_DRV_main():: SNIM_DRV_CHECK_LOCK::SNIM_STATE_LOCKED State......[%d]..... \n\r",AcquisitionResult));
			return 1;
		}
		else if (AcquisitionResult > SNIM_STATE_LOCKED)
		{
			#if defined(TUNER_TIMING_SHORTEN)
				int timeout = 300;
			#else
			int timeout = 9000;
			#endif
			printSn15(("FE_DRV_main():: SNIM_DRV_CHECK_LOCK::DEMOD Busy now.... Wait a moment......[%d]... \n\r",AcquisitionResult));
			while( (AcquisitionResult > SNIM_STATE_LOCKED) && timeout)
			{
				
				#if defined(TUNER_TIMING_SHORTEN)
					FE_Wait(2); 
				#else
				FE_Wait(10); 
				#endif
				timeout--;
				AcquisitionResult = SnimRead(g_hTheSnim, SNIM_DATA_DEMODSTATE);				
			}

			if (AcquisitionResult == SNIM_STATE_LOCKED) 
			{
				printSn15(("FE_DRV_main():: SNIM_DRV_CHECK_LOCK::DEMOD  goes LOCK state.....[%d]...TIMEout[%d].. \n\r",AcquisitionResult, timeout));
				return 1;
			}
			else
			{
				printSn15(("FE_DRV_main():: SNIM_DRV_CHECK_LOCK::DEMOD  goes idle state.....[%d]..TIMEout[%d]... \n\r",AcquisitionResult, timeout));
				return 0;
			}
		}
		else 
		{

			printSn15(("FE_DRV_main():: SNIM_DRV_CHECK_LOCK::DEMOD Unknown State......[%d]..... \n\r",AcquisitionResult));
			return 0;
		}
}


/*****************************internal functions*******************************/
/************************Zarlink Semiconductor*********************************
*   Name:TestsnimAcquireChannel()
*   Purpose: Acquires a channel, either from scan list or manually specified
*   Remarks:
* 
*   Inputs:
*
*   Outputs:
*
********************************************************************************/
void TestsnimAcquireChannel(void)
{
	SSnimChannel channel;
	int MenuChoice = ACQMENU_MANUAL;
    channel.ucExt=0;
    channel.ucSat=0;

	
	if (g_ChannelCount>0) MenuChoice=TestsnimGetMenuChoice(&g_AcquireMenu);

	switch (MenuChoice)
	{
	case ACQMENU_FROMLIST:
		TestsnimPrintChannelList();
		SnimAcquire(g_hTheSnim,TestsnimGetChannelFromList((int)TestsnimGetKBnumber("Enter channel number",1,g_ChannelCount,FALSE)));
		break;
	case ACQMENU_MANUAL:
		/* satellite */
		if ('1'==TestsnimGetKBletter("Satellite 1 or 2?","12",TRUE))
			channel.ucSat=0;
		else
			channel.ucSat=1;
	
		/*polarisation */
		if ('H'==TestsnimGetKBletter("Polarisation H or V?","hHvV",TRUE))
			channel.ucExt |=SCHANNELEXT_HORIZONTAL;
		else
			channel.ucExt &=~SCHANNELEXT_HORIZONTAL;
				
		/*frequency */
		channel.MHz=(Uint16T)TestsnimGetKBnumber("Enter frequency",400,16000,FALSE);

		/* symbol rate*/
 		
		channel.kRs = (Uint16T) TestsnimGetKBfloat("Symbol rate Msym/sec",1000,46000);
		SnimAcquire(g_hTheSnim,&channel);

		break;
	default:/* exit system*/;
	}


	

}
/************************Zarlink Semiconductor*********************************
*   Name:TestsnimPrintStatus()
*   Purpose:Prints the current status of the snim.
*   Remarks:
* 
*   Inputs:
*
*   Outputs:
*
********************************************************************************/
SSnimChannel Snim_Drv_BlindStatus(SSnimChannel *pChannelData,unsigned long *pDemodeState,unsigned char *nProgress)
{

	const char wind[5]="|/-\\";
	static int mill=0;
	SSnimChannel channel;
	Uint32T err;
	int dp1,dp2,expon;
	static Uint32T dwTimeRef=0;


	SnimReadChannel(g_hTheSnim,pChannelData);

	printSn15Console("\r%c ",wind[mill]); /* beginning of the line */
	if (++mill>3) mill=0;
	/* demod state*/
	*pDemodeState = SnimRead(g_hTheSnim,SNIM_DATA_DEMODSTATE);
	*nProgress = (SnimRead(g_hTheSnim,SNIM_DATA_PROGRESS)+5)/10;//100%
}

void Snim_Drv_PrintStatus(void)
{

	const char wind[5]="|/-\\";
	static int mill=0;
	SSnimChannel channel;
	Uint32T err;
	int dp1,dp2,expon;
	static Uint32T dwTimeRef=0;


	if (((unsigned long)(g_dwClock-dwTimeRef))<500) 
	{
		
		//return;
	}
	dwTimeRef=g_dwClock;

	SnimReadChannel(g_hTheSnim,&channel);

	printSn15Console("\r%c ",wind[mill]); /* beginning of the line */
	if (++mill>3) mill=0;
	/* demod state*/
	switch (SnimRead(g_hTheSnim,SNIM_DATA_DEMODSTATE))
	{
		case SNIM_STATE_OFF:		printSn15Console(TXT_OFF);break;
		case SNIM_STATE_STANDBY:	printSn15Console(TXT_STANDBY);break;
		case SNIM_STATE_IDLE:		printSn15Console(TXT_IDLE);break;
		case SNIM_STATE_BUSY:		printSn15Console(TXT_BUSY);break;
		case SNIM_STATE_WAITING:	printSn15Console(TXT_WAITING);break;
		case SNIM_STATE_SCANNING:	printSn15Console(TXT_SCANNING);break;
		case SNIM_STATE_LOCKED:   	printSn15Console(TXT_LOCKED);break;
		default:                printSn15Console(TXT_BLANK);break;

	}



	/* Tuning info*/
	printSn15Console(" %d   %s %6d (%4d.%d) ",channel.ucSat+1,(channel.ucExt &SCHANNELEXT_HORIZONTAL) ?"H":"V",
		channel.MHz,
		SnimRead(g_hTheSnim,SNIM_DATA_TUNERFREQ)/1000,
		((SnimRead(g_hTheSnim,SNIM_DATA_TUNERFREQ)+50)/100)%10);

	if (g_isScanning)
	{/* print scan info */
		printSn15Console (" %3d%%  ",(SnimRead(g_hTheSnim,SNIM_DATA_PROGRESS)+5)/10);
		printSn15Console("found %4d   ",g_ChannelCount);
	}

	else
	{/* print live channel data */
		/*symbol rate */
		printSn15Console("%2d.%03d ",RS_INT(channel.kRs),RS_FRAC(channel.kRs));
		/* code rate */
		printSn15Console("%d/%d ",channel.ucExt & SCHANNELEXT_CODERATE,(channel.ucExt & SCHANNELEXT_CODERATE)+1);

		/* ebNo */
		printSn15Console ("%2d.%d ",SnimRead(g_hTheSnim,SNIM_DATA_EBNOx10)/10,SnimRead(g_hTheSnim,SNIM_DATA_EBNOx10)%10);
		/* AGC*/
		printSn15Console ("%4d ",SnimRead(g_hTheSnim,SNIM_DATA_AGC));
		/* error */
		/* integer value is x10^9*/

		if (SNIM_STATE_LOCKED==SnimRead(g_hTheSnim,SNIM_DATA_DEMODSTATE))
		{
			err = SnimRead(g_hTheSnim,SNIM_DATA_POSTVITBER); 
		}
		else
		{
			err=Uint32T_MAX;
		}

		dp1=0;
		dp2=0;
		expon=9;
		if (err==0)
		{
			printSn15Console("(%3d%% )    0   ",(SnimRead(g_hTheSnim,SNIM_DATA_PROGRESS)+5)/10);
		}
		else if(err == Uint32T_MAX)
		{
			printSn15Console("(%3d%% )   ---  ",(SnimRead(g_hTheSnim,SNIM_DATA_PROGRESS)+5)/10);
		}
		else
		{/* convert to floating point format */
			while(err>=10)
			{
				dp2=dp1;
				dp1=(int)(err%10);
				err/=10;
				expon--;
			}
			printSn15Console("(%3d%% ) %d.%d%dE-%d",(SnimRead(g_hTheSnim,SNIM_DATA_PROGRESS)+5)/10,(int)err,dp1,dp2,expon);
		}
	}
	printSn15Console("\n\r");
}


void TestsnimPrintStatus(void)
{

	const char wind[5]="|/-\\";
	static int mill=0;
	SSnimChannel channel;
	Uint32T err;
	int dp1,dp2,expon;
	static Uint32T dwTimeRef=0;


	if (((unsigned long)(g_dwClock-dwTimeRef))<500) 
	{
		
		//return;
	}
	dwTimeRef=g_dwClock;

	SnimReadChannel(g_hTheSnim,&channel);

	printSn15Console("\r%c ",wind[mill]); /* beginning of the line */
	if (++mill>3) mill=0;
	/* demod state*/
	switch (SnimRead(g_hTheSnim,SNIM_DATA_DEMODSTATE))
	{
		case SNIM_STATE_OFF:		printSn15Console(TXT_OFF);break;
		case SNIM_STATE_STANDBY:	printSn15Console(TXT_STANDBY);break;
		case SNIM_STATE_IDLE:		printSn15Console(TXT_IDLE);break;
		case SNIM_STATE_BUSY:		printSn15Console(TXT_BUSY);break;
		case SNIM_STATE_WAITING:	printSn15Console(TXT_WAITING);break;
		case SNIM_STATE_SCANNING:	printSn15Console(TXT_SCANNING);break;
		case SNIM_STATE_LOCKED:   	printSn15Console(TXT_LOCKED);break;
		default:                printSn15Console(TXT_BLANK);break;

	}



	/* Tuning info*/
	printSn15Console(" %d   %s %6d (%4d.%d) ",channel.ucSat+1,(channel.ucExt &SCHANNELEXT_HORIZONTAL) ?"H":"V",
		channel.MHz,
		SnimRead(g_hTheSnim,SNIM_DATA_TUNERFREQ)/1000,
		((SnimRead(g_hTheSnim,SNIM_DATA_TUNERFREQ)+50)/100)%10);

	if (g_isScanning)
	{/* print scan info */
		printSn15Console (" %3d%%  ",(SnimRead(g_hTheSnim,SNIM_DATA_PROGRESS)+5)/10);
		printSn15Console("found %4d   ",g_ChannelCount);
	}

	else
	{/* print live channel data */
		/*symbol rate */
		printSn15Console("%2d.%03d ",RS_INT(channel.kRs),RS_FRAC(channel.kRs));
		/* code rate */
		printSn15Console("%d/%d ",channel.ucExt & SCHANNELEXT_CODERATE,(channel.ucExt & SCHANNELEXT_CODERATE)+1);

		/* ebNo */
		printSn15Console ("%2d.%d ",SnimRead(g_hTheSnim,SNIM_DATA_EBNOx10)/10,SnimRead(g_hTheSnim,SNIM_DATA_EBNOx10)%10);
		/* AGC*/
		printSn15Console ("%4d ",SnimRead(g_hTheSnim,SNIM_DATA_AGC));
		/* error */
		/* integer value is x10^9*/

		if (SNIM_STATE_LOCKED==SnimRead(g_hTheSnim,SNIM_DATA_DEMODSTATE))
		{
			err = SnimRead(g_hTheSnim,SNIM_DATA_POSTVITBER); 
		}
		else
		{
			err=Uint32T_MAX;
		}

		dp1=0;
		dp2=0;
		expon=9;
		if (err==0)
		{
			printSn15Console("(%3d%% )    0   ",(SnimRead(g_hTheSnim,SNIM_DATA_PROGRESS)+5)/10);
		}
		else if(err == Uint32T_MAX)
		{
			printSn15Console("(%3d%% )   ---  ",(SnimRead(g_hTheSnim,SNIM_DATA_PROGRESS)+5)/10);
		}
		else
		{/* convert to floating point format */
			while(err>=10)
			{
				dp2=dp1;
				dp1=(int)(err%10);
				err/=10;
				expon--;
			}
			printSn15Console("(%3d%% ) %d.%d%dE-%d",(SnimRead(g_hTheSnim,SNIM_DATA_PROGRESS)+5)/10,(int)err,dp1,dp2,expon);
		}
	}
	printSn15Console("\n\r");
}

/************************Zarlink Semiconductor*********************************
*   Name:TestsnimProcessCommands()
*   Purpose:checks for keyboard activity, and activates the menu system
*   Remarks:
* 
*   Inputs:
*
*   Outputs:
*
********************************************************************************/




void TestsnimProcessCommands(void)
{



	TestsnimStartScan();
	TestsnimPrintStatusHdr();
	#if 0
	if (TestsnimKBHit())
	{
		switch(TestsnimGetMenuChoice(&g_MainMenu))
		{
		case MAINMENU_ACQUIRE:
			TestsnimAcquireChannel();
			break;
		case MAINMENU_XTAL:
			TestsnimSetXtal();
			break;
		case MAINMENU_POWER:
			switch(TestsnimGetMenuChoice(&g_PowerMenu))
			{
				case POWERMENU_OFF:SnimCommand(g_hTheSnim,SNIM_COMMAND_POWER_OFF);break;
				case POWERMENU_ON:SnimCommand(g_hTheSnim,SNIM_COMMAND_POWER_ON);break;
			}
			break;
					
		case MAINMENU_SCAN:TestsnimStartScan();	break;
		case MAINMENU_SETLPT:g_isPortOpen = TestsnimOpenPort(NULL);	break;
		case MAINMENU_LNBTYPE:TestsnimSetLNB();break;
		case MAINMENU_REGDUMP:TestDumpRegisters();break;
		case MAINMENU_EXITPROG: 
			g_isActive=FALSE;
			break;