detect.c

主要用于液晶电视解码,内置51单片机,全部代码用C编写,编译环境为KEILC

#define _DETECT_C_

#include <math.h>
#include "types.h"
#include "board.h"
#if VGA_ENABLE
#include "global.h"
#include "ms_reg.h"
#include "ms_rwreg.h"
#include "power.h"
#include "DEBUG.h"
#include "misc.h"
#include "menu.h"
#include "UserPref.h"
#include "msOSD.h"
#include "panel.h"
#include "mStar.h"
#include "DevVD.h"
#include "detect.h"
#include "Menufunc.h"
#include "mstar.h"

void Menu_InitAction(void)
{
    if (SyncLossState())
    {
    	/*if(FactoryModeFlag)
		    g_ucMenuPageIndex=FactoryRootMenu;
	    else*/
        	g_ucMenuPageIndex=StandbyMenu;
    }
    else if (UnsupportedModeFlag)
    {
            g_ucMenuPageIndex=UnsupportedModeMenu;
    }
    else if (g_ModeSetting.AutoTimes==0 )
    {
    	/*if(FactoryModeFlag)
		    g_ucMenuPageIndex=FactoryRootMenu;
	    else*/
       	    g_ucMenuPageIndex=AutoMenu;
    }
    else
        g_ucMenuPageIndex=RootMenu;

           if(FactoryModeFlag) //hyy 2007 01 26
		    g_ucMenuPageIndex=FactoryRootMenu;

  	g_ucMenuItemIndex=0;
  	g_ucOsdCounter=0;
  	ExecuteKeyEvent(MIA_RedrawMenu);
	WatchDogClear();

	//AutoConfig();
    if (UnsupportedModeFlag)
    {
	    if(!FreeRunModeFlag)
	  	{
	  	    if (g_ModeSetting.AutoTimes	==0 )
	            AutoConfig();
	  	}
    }
}
//*******************************************************************
// Function Name: msMonitorInputTiming
//
// Decscription: Detect input timing
//
// callee: msSyncLossStateDetect(), msValidTimingDetect(), msAutoDVI() in detect.c
//         msSetInputPort(),  in mstar.c
//
// caller: main() in main.c
//*******************************************************************
void msMonitorInputTiming(void)
{
	if (!PowerOnFlag)
    	return;

#if Enable_Logo_Display
    if(DrawLogoFlag)
	return;
#endif

  // detect whether input signal is changing
  	if (!g_bInputTimingChangeFlag)
    {
    	if (SyncLossState())
        {
	        if (!FreeRunModeFlag)
	        	{//printMsg("!FreeRunModeFlag");
	              Set_InputTimingChangeFlag();
	        	}
	        else if (msSyncLossStateDetect()) // detect mode while no Sync/suspend/standby/disconnect
	              {//printMsg("msSyncLossStateDetect");
	              Set_InputTimingChangeFlag();
	        	}
        }
      	else // valid timing
        { // check if input timing is changing
          if (msValidTimingDetect())
            { //printMsg("msValidTimingDetect");
              SrcFlags|=SyncLoss;
              Set_InputTimingChangeFlag();
            }
      	}
    }

  //=============================================================================
  //=============================================================================
    if (g_bInputTimingChangeFlag) // input timing is unstable
    {
        Clr_InputTimingChangeFlag();
        Clr_DoModeSettingFlag();
        g_ucTimingChangeDebunce++;
        if (!SyncLossState())// && !InputTimingStableFlag) // prevent from SOG
  	    {
  	        if (g_ucTimingChangeDebunce<=3)
            {
                SrcFlags|=SyncLoss;
                return;
            }
        }
      msPrepareForTimingChange();
	//printMsg("VGA InputTimingChange");
    }
    else // input timing is stable
    {
        g_ucTimingChangeDebunce=0;
        g_ucInputTimingStableCounter++; // counter timing stable times
        if (g_ucInputTimingStableCounter==0)
      	    g_ucInputTimingStableCounter=1;
        if (!InputTimingStableFlag)
        {
        	if ((!SyncLossState() && g_ucInputTimingStableCounter>=ValidTimingStableCount)|| // set timing stable flag
               (SyncLossState() && g_ucInputTimingStableCounter>=SyncLossStableCount))
            {
                Set_InputTimingStableFlag();// set flag to search for input mode
                Set_DoModeSettingFlag();
            }
        }
    }
}


//*******************************************************************
// Function Name: msModeHandler
//
// Decscription: Programming scaler while input timing is changing
//
// callee: msSyncLossStateDetect(), msValidTimingDetect(), msAutoDVI() in detect.c
//         msSetInputPort(),  in mstar.c
//
// caller: main() in main.c
//*******************************************************************
void msModeHandler(void)
{
    if (!DoModeSettingFlag) // while timing change & stable
        return;

    printMsg("VGA mode set up");
  	Clr_DoModeSettingFlag();

  	if (!SyncLossState()) // no sync
		{
	    	if (!msFindMode()) // search mode index
	        {
	            printMsg("mode find fail");
	        	Set_InputTimingChangeFlag(); // search mode faile
	          	return;
	        }

	      	if (!UnsupportedModeFlag) //supported mode
	        {
	        	printf("\r\ninput timing index = %d", g_ucSrcModeIndex);
	          	ReadModeSetting(); // restore user's settings from NVRAM for each mode
	          	if (msSetupMode()==FALSE) // setup scaler
		        {
		        	Set_InputTimingChangeFlag(); // setup mode failed
		            msSetBlueScreen( _ENABLE, FR_BLACK); // setup freerun mode
		            printMsg("Failed to setup mode");
		            return;
	            }
	          	if (UnsupportedModeFlag)
	            {
	            	printMsg("Failed: Out of panel spec");
	            }

	        }
	        else
	            printMsg("unsupported mode");
	    }

  	if (SyncLossState() || UnsupportedModeFlag)
    {
      	msSetBlueScreen( _ENABLE, FR_BLUE); // setup freerun mode
      	Power_TurnOffGreenLed(); // turn off green led
    }
  	else
    	Power_TurnOnGreenLed(); // turn on green led

	 msSetScaler();

	 msSetInterrupt(INTERRUPT_PC);

  	 Power_TurnOnPanel(); // turn on panel
 	 Menu_InitAction(); // initial menu osd state
}

void msPrepareForTimingChange(void)
{

    msSetInterrupt(INTERRUPT_DISABLE);
    Clr_ForcePowerSavingFlag();
    g_ucPowerDownCounter=0;

    if (PowerSavingFlag)
        Power_PowerOnSystem();
    else
        Power_TurnOffPanel();

    msSetBlueScreen( _ENABLE, FR_BLUE);

    Osd_Hide();

    if (InputTimingStableFlag)
    {
    	msWriteByte(BK0_E2_SWRST0, OP2R_B|ADCR_B);// Reset Graphic port to re-counter input hfreq & vtotal
      	Delay1ms(3);
      	msWriteByte(BK0_E2_SWRST0, 0);
      	Delay1ms(20);
    }

  Clr_InputTimingStableFlag();	 // reset input timing stable and wait for timing stable
  g_ucInputTimingStableCounter=0;
  SrcFlags&=~(bUnsupportMode|bUserMode|bNativeMode);

}
//==========================================================

BOOL msSyncLossStateDetect(void)
{
    BYTE fStatus;
    BOOL result=TRUE;

    fStatus=msGetInputStatus();
    if (fStatus&SyncLoss)
      result=FALSE;
    else
      SrcFlags=(SrcFlags&0xF0)|fStatus; // clear others flags, except sync informat (polarity & w/o)
    return result;
}

BOOL msValidTimingDetect(void)
{
    BYTE fStatus;

    fStatus=msGetInputStatus();

    if (fStatus&SyncLoss) // no sync
    {
        SrcFlags=(SrcFlags&0xF0)|fStatus; // clear others flags, except sync informat (polarity & w/o)
        return TRUE;
    }
    else
    {
        if (SyncPolarity(SrcFlags)!=SyncPolarity(fStatus)) // Sync polarity changed
        {
            SrcFlags=(SrcFlags&0xF0)|fStatus; // clear others flags, except sync informat (polarity & w/o)
            return TRUE;
  	    }
        else
      	{
      	    WORD tempPeriod;

            SrcFlags=(SrcFlags&0xF0)|fStatus; // clear others flags, except sync informat (polarity & w/o)
            tempPeriod=msReadWord(BK0_EB_HSPRD_H)&0x1FFF;
            //printf("HPeriod %d", tempPeriod);
            if (g_ucInputTimingStableCounter==0)
                SrcHPeriod=tempPeriod;
            if (abs(tempPeriod-SrcHPeriod)>HPeriod_Torlance) // HPeriod changed
            {
                //printf("\r\nHPeriod %d", tempPeriod);
                return TRUE;
            }

            tempPeriod=msReadWord(BK0_ED_VTOTAL_H)&0x7FF;
            //printf("VTotal %d", tempPeriod);
            if (g_ucInputTimingStableCounter==0)
                SrcVTotal=tempPeriod;
            if (abs(tempPeriod-SrcVTotal)>VTotal_Torlance) // vtotal changed
            {
                //printf("\r\nVTotal %d", tempPeriod);
                return TRUE;
            }
      	}
    }
    return FALSE;
}

BOOL msFindMode(void)
{
    WORD hFreq, vFreq;

    #define fStatus	 hFreq
    fStatus=msGetInputStatus();
    if (SyncPolarity(SrcFlags)!=SyncPolarity(fStatus)) // Sync polarity changed
        return FALSE;
    SrcFlags&=0x0F;
    #undef fStaus

    g_wHorizontalPeriod = msGetHorizontalPeriod();