📄 userpref.c

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

#define _USERPREF_C_

#include <math.h>
#include "types.h"
#include "board.h"
#include "global.h"
#include "nvram.h"
#include "DEBUG.h"
#include "menudef.h"
#include "menufunc.h"
#include "i2c.h"
#include "tv.h"
#include "panel.h"
#include "mstar.h"
#include "msAce.h"
#include "adjust.h"
#include "userpref.h"
#include "ms_rwreg.h"
#define HFreq_Tol	16 // 1.6 KHz
#define VFreq_Tol	8  // 0.8 Hz


BYTE usrCalCheckSum(BYTE *pBuf, BYTE ucBufLen)
{
    BYTE CheckSum;
    CheckSum = 0;
    do
    {
        CheckSum += pBuf[ucBufLen-1];
        ucBufLen--;
    }
    while(ucBufLen);

    return CheckSum;
}

#if VGA_ENABLE
void InitPCSetting(void)
{
    g_PcSetting.Brightness=DefBrightness;
    g_PcSetting.Contrast=DefContrast;

    g_PcSetting.AdcRedGain=0x80;
    g_PcSetting.AdcGreenGain=0x80;
    g_PcSetting.AdcBlueGain=0x80;
    g_PcSetting.AdcRedOffset=0x80;
    g_PcSetting.AdcGreenOffset=0x80;
    g_PcSetting.AdcBlueOffset=0x80;

    g_PcSetting.SavedModeIndex=UserModeNumber;
}
#endif

void InitVideoSetting(void)
{
  //putstr("\r\nInit Video Setting!");
    g_VideoSetting.ucVersion=VideoVersion;

    g_VideoSetting.Language=0;
    g_VideoSetting.OsdHStart=50;
    g_VideoSetting.OsdVStart=50;
    g_VideoSetting.InputType=Input_CVBS1;

    g_VideoSetting.volume=50;
    g_VideoSetting.MuteStatus=0;

    g_VideoSetting.MonitorFlag=bPowerOnBit;

    g_VideoSetting.VideoBrightness = DefVideoBrightness;
    g_VideoSetting.VideoContrast =   DefVideoContrast;
    g_VideoSetting.VideoSaturation = DefVideoSaturation;
    g_VideoSetting.VideoHue =        DefVideoHue;
    g_VideoSetting.VideoSharpness=	2;

    g_VideoSetting.DOWN=0;
    g_VideoSetting.Scaling=Scaling_Full;
    g_VideoSetting.TunerAGC=0x10;

    g_VideoSetting.OsdTime=2;
    g_VideoSetting.VideoColorSys=0;
    g_VideoSetting.videoAGC=8;

    g_VideoSetting.VcomDC =SET_BVOM_DC;
    g_VideoSetting.VcomAC =SET_BVOM_OUT;

    #if TV_ENABLE
    g_TVChSetting.ucCurChannelNO =0;
    g_TVChSetting.ucPreChannelNO =0;

    {
	BYTE ucTemp;
    for(ucTemp=0;ucTemp<((TV_MAX_CHANNEL_NUM+1)/8)+2;ucTemp++)
	g_ucTVChannelSkipInfoBuff[ucTemp]=0;
	WatchDogClear();

#if TV_SYSTEM==TV_NTSC
    g_TVChSetting.ucTVSource=NTSC_ATV;
    g_TVChSetting.ucATVChannelNO=0;
    g_TVChSetting.ucCTVChannelNO=0;

    for(ucTemp=0;ucTemp<((CATV_MAX_CHANNEL_NUM+1)/8)+2;ucTemp++)
	g_ucCATVChannelSkipInfoBuff[ucTemp]=0;
#endif

    EraseTvSkipInfo();

    }
    #endif
}

void SaveVideoSetting(void)
{
	//putstr("\r\nSave Video Setting!");
    g_VideoSetting.Checksum= usrCalCheckSum((BYTE *)&g_VideoSetting, (VideoSettingSize - CheckSumSize));
	NVRam_WriteTbl(VideoSettingAddr, (BYTE*)&g_VideoSetting, VideoSettingSize);
}

#if VGA_ENABLE
void SavePCSetting(void)
{
    g_PcSetting.Checksum= usrCalCheckSum((BYTE *)&g_PcSetting, PCSettingSize - CheckSumSize);
	NVRam_WriteTbl(PCSettingAddr, (BYTE*)&g_PcSetting, PCSettingSize);
}

void LoadPCSetting(void)
{
	BYTE ucCheckSum;

#ifndef TempMask
    NVRam_ReadTbl(PCSettingAddr, (BYTE*)&g_PcSetting, PCSettingSize);
#endif
    ucCheckSum=usrCalCheckSum((BYTE *)&g_PcSetting, PCSettingSize - CheckSumSize);

	if(g_PcSetting.Checksum!=ucCheckSum)
	{
		InitPCSetting();
		SavePCSetting();
	}
}
#endif

void msChipVersionRead(void)
{
    BYTE ucBank;
    BYTE ucChip_D_Version=0;
    ucBank=msReadByte(BK0_00_REGBK);
    msWriteByte(BK0_00_REGBK, REG_BANK_SCALER);
    ucChip_D_Version=msReadByte(BK0_F1_CHIP_VERSION);

    switch(ucChip_D_Version)
	{
	case 5:
		VD_Type=MARIA2_F;
		break;
	case 4:
		VD_Type=MARIA2_E;
		break;
	case 3:
		VD_Type=MARIA2_D;
		break;
	default:
	case 6:
		VD_Type=MARIA2_G;
		break;
	}

    msWriteByte(BK0_00_REGBK, ucBank);
}

#if RM_EEPROM_TYPE<RM_TYPE_SST512
void LoadVideoSetting(void)
{
	BYTE ucCheckSum;

	//putstr("\r\nLoad Video Setting!");
    NVRam_ReadTbl(VideoSettingAddr, (BYTE*)&g_VideoSetting, VideoSettingSize);
    ucCheckSum=usrCalCheckSum((BYTE *)&g_VideoSetting, VideoSettingSize - CheckSumSize);

	if(g_VideoSetting.Checksum!=ucCheckSum)
	{
		InitVideoSetting();
		SaveVideoSetting();
	}
}

BOOL CheckBoard(void)
{
	BYTE  i=5,j=5, temp;
	BOOL VideoSumOk, BoardSumOK;

  	while(i--)
  	{
		NVRam_ReadByte(nvrVideoAddr(ucVersion), &(g_VideoSetting.ucVersion));

		if (g_VideoSetting.ucVersion==VideoVersion)
		{
			VideoSumOk=TRUE;
			break;
		}
		else
			VideoSumOk=FALSE;
  	}

  	while(j--)
  	{
	    NVRam_ReadByte(BoardChkSumAddr, &temp);

		if (temp==BoardVersion)
		{
			BoardSumOK=TRUE;
			break;
		}
		else
			BoardSumOK=FALSE;
  	}

	printf("\r\nBoardVer<%x>", temp);

    if(BoardSumOK&&VideoSumOk)
	    return TRUE;
    else
        return FALSE;
}


void ReadSetting(void)
{
    BOOL tempValue;
    tempValue=CheckBoard();

    if (tempValue)
    {
        #if VGA_ENABLE
        LoadPCSetting();
        #endif

        LoadVideoSetting();

	#if TV_ENABLE
	ReadChannelNumberSetting();

	ReadChannelSkipInfoSetting();
	#endif
    }
    else
    {
  	    putstr("\r\nUpdate!");
        #if VGA_ENABLE
	    InitPCSetting();
	    SavePCSetting();
	    InitSaveModeFlag();
        #endif

	    InitVideoSetting();
	    SaveVideoSetting();

        #if TV_ENABLE
        SaveChannelNumberSetting();

	#if TV_SYSTEM==TV_PAL
        EraseEepromTvFlag(0);
	#endif
        #endif

        NVRam_WriteByte(BoardChkSumAddr, BoardVersion);
    }

}
#else

#define CS_ERR  _BIT0
#define VER_ERR  _BIT1

BYTE CheckFlashDataBlockError(BOOL Block)
{
    BYTE ErrorType;
    BYTE i;
    BYTE ucCheckSum;

    for(i=0;i<5;i++)
    {
    		ErrorType=0;
        if(!Block)
            mstLoadDisplayData(SFD_ADDRESS);
        else
            mstLoadDisplayData(SFD_ADDRESS+0x1000);

        ucCheckSum=usrCalCheckSum((BYTE *)&g_VideoSetting, VideoSettingSize - CheckSumSize);

        if(g_VideoSetting.Checksum!=ucCheckSum)
            ErrorType|=CS_ERR;

        if(g_VideoSetting.ucVersion!=VideoVersion)
            ErrorType|=VER_ERR;

        if(!ErrorType)
            break;
    }

    return ErrorType;
}


void ReadSetting(void)
{
    BYTE Block0Err;
    BYTE Block1Err;

	if(g_bFlashReadOK)
		return;

    Block0Err=CheckFlashDataBlockError(0);
    Block1Err=CheckFlashDataBlockError(1);

    if(Block0Err&&!Block1Err) //Block0 error, Block1 OK, restore Block1 to Block0
    {
  	    putstr("\r\nBlock0 Err!");
		SaveVideoSetting();
    }
    else if(!Block0Err&&Block1Err)
    {
  	    putstr("\r\nBlock1 Err!");
        CheckFlashDataBlockError(0);
		SaveVideoSetting();
    }
    else if(Block0Err&&Block1Err)
    {
  	    putstr("\r\nUpdate!");
		InitVideoSetting();
		SaveVideoSetting();
    }
    else
    {
  	    putstr("\r\nLoad OK!");
    }

	g_bFlashReadOK=1;
}

#endif

//*******************************************************************
// Function Name: msSetUserPref
//
// Decscription: Restore user setting from NVRAM
//
// callee: msWriteByte() in ms_rwreg.c
//
// caller: msSetupMode() in mStar.c
//*******************************************************************
void msSetUserPref(void)
{
    BYTE tempSat,tempCon,tempBri;
    if(IsVideoPortInUse())
    {
	    msAdjustVideoRGB (RedGain, GreenGain, BlueGain);
	    msAdjustVideoCbCr(CbGain, CrGain );

	    tempSat=usrNonLinearCalculate(g_NLCVideoSaturation,g_VideoSetting.VideoSaturation);
	    tempCon=usrNonLinearCalculate(g_NLCVideoContrast,g_VideoSetting.VideoContrast);
        #if TV_ENABLE
        if(IsTVInUse())
            tempCon+=TV_EXTR_CONTRAST;
        #endif
	    msAdjustHSC(g_VideoSetting.VideoHue, tempSat, tempCon);
           msAdjustVideoHue(g_VideoSetting.VideoHue);
	    tempBri=usrNonLinearCalculate(g_NLCVideoBrightness,g_VideoSetting.VideoBrightness);
	    msAdjustBrightness(tempBri);
    }
    else
    {
  	    tempBri=usrNonLinearCalculate(g_NLCVideoBrightness,g_PcSetting.Brightness);
	    msAdjustBrightness(tempBri);
	    msAdjustPCContrast(g_PcSetting.Contrast);
    }
}

//**************************************************************************************************************//
#if TV_ENABLE
void EraseTvSkipInfo(void)
{
WatchDogClear();
 NVRam_WriteTbl(TV_SKIP_INFOAddr, g_ucTVChannelSkipInfoBuff, ((TV_MAX_CHANNEL_NUM+1)/8+1));
 #if TV_SYSTEM==TV_NTSC
 NVRam_WriteTbl(CATV_SKIP_INFOAddr, g_ucCATVChannelSkipInfoBuff, (CATV_MAX_CHANNEL_NUM+1)/8+1);
 #endif
}

void ReadChannelSkipInfoSetting(void)
{
WatchDogClear();
 NVRam_ReadTbl(TV_SKIP_INFOAddr, g_ucTVChannelSkipInfoBuff, (TV_MAX_CHANNEL_NUM+1)/8+1);
 #if TV_SYSTEM==TV_NTSC
 NVRam_ReadTbl(CATV_SKIP_INFOAddr, g_ucCATVChannelSkipInfoBuff, (CATV_MAX_CHANNEL_NUM+1)/8+1);
 #endif
}

#if TV_SYSTEM==TV_PAL
void EraseEepromTvFlag(BYTE StartChannal)
{
	BYTE channel;
	for(channel=StartChannal;channel<=TV_MAX_CHANNEL_NUM-1;channel++)
    {
		WatchDogClear();
		NVRam_WriteByte((nvrChanneAddr(channel)+MISCOFFSETADDR), TV_SOUND_I|DoAFCFlag);
    }
}
#endif

void CheckChannelNumberSettingRang()
{
#if TV_SYSTEM==TV_PAL
    g_TVChSetting.ucCurChannelNO %=TV_MAX_CHANNEL_NUM;
    g_TVChSetting.ucPreChannelNO %=TV_MAX_CHANNEL_NUM;
#else

    g_TVChSetting.ucTVSource%=NTSC_SOURCE_NUM;

    if(g_TVChSetting.ucTVSource==NTSC_ATV)
    	{
    	g_TVChSetting.ucCurChannelNO %=TV_MAX_CHANNEL_NUM;
    	g_TVChSetting.ucPreChannelNO %=TV_MAX_CHANNEL_NUM;

    	}
	else
	{
    	g_TVChSetting.ucCurChannelNO %=CATV_MAX_CHANNEL_NUM;
    	g_TVChSetting.ucPreChannelNO %=CATV_MAX_CHANNEL_NUM;
	}

    g_TVChSetting.ucATVChannelNO%=TV_MAX_CHANNEL_NUM;
    g_TVChSetting.ucCTVChannelNO%=CATV_MAX_CHANNEL_NUM;
#endif
    g_VideoSetting.TunerAGC%=0x20;
}

void ReadChannelNumberSetting(void)
{
    NVRam_ReadTbl(ChannelNumberInfoAddr, (BYTE*)&g_TVChSetting, ChannelNumberInfoSize);
    CheckChannelNumberSettingRang();
}

void SaveChannelNumberSetting(void)
{
  	NVRam_WriteTbl(ChannelNumberInfoAddr, (BYTE*)&g_TVChSetting, ChannelNumberInfoSize);
}
#endif

//**************************************************************************************************************//
#if VGA_ENABLE
void InitSaveModeFlag(void)
{
  	NVRam_WriteByte(nvrMonitorAddr(Checksum), 0);

  	for (g_ucSaveIndex=0; g_ucSaveIndex<NumberOfMode; g_ucSaveIndex++)
  	{
  		WatchDogClear();
	    NVRam_WriteByte(nvrModeAddr(checksum), 0);
  	}
}

void InitModeSetting(void)
{
    g_ModeSetting.HTotal=StandardModeHTotal;
    g_ModeSetting.HStart=StandardModeHStart;
    g_ModeSetting.VStart=StandardModeVStart;
    g_ModeSetting.AutoHStart=g_ModeSetting.HStart;
    g_ModeSetting.AutoHStart=g_ModeSetting.VStart;
    g_ModeSetting.Phase=0x1F;
    g_ModeSetting.AutoTimes=0;
    g_ModeSetting.checksum=ModeCSValue;
}

void CheckModeSettingRange(void)
{
    if (abs(g_ModeSetting.HTotal-StandardModeHTotal)>ClockAdjRange)
        g_ModeSetting.HTotal=StandardModeHTotal;
    if (g_ModeSetting.HStart>2*StandardModeHStart)
        g_ModeSetting.HStart=StandardModeHStart;
    if (g_ModeSetting.VStart>2*StandardModeVStart)
        g_ModeSetting.VStart=StandardModeVStart;

    g_ModeSetting.Phase&=0x3F;

    if (g_ModeSetting.AutoTimes==0 || abs(g_ModeSetting.HStart-g_ModeSetting.AutoHStart)>50)
        g_ModeSetting.AutoHStart=g_ModeSetting.HStart;
}



void SaveModeSetting(void)
{
    NVRam_WriteTbl(nvrModeBaseAddr(g_ucSaveIndex), (BYTE*)&g_ModeSetting, ModeSettingSize);
}

void GetModeSaveIndex(void)
{
    ModeInfoType modeInfo;
    BYTE i;
    WORD hFreq, vFreq;

    hFreq=HFreq(SrcHPeriod);
    vFreq=VFreq(hFreq, SrcVTotal);
    for (i=0; i<UserModeNumber; i++)
    {
#ifndef TempMask
      NVRam_ReadTbl(nvrModeInfoAddr(i) , (BYTE*)&modeInfo, ModeInfoSize);
#endif
      if (abs(hFreq-modeInfo.HorFreq)<HFreq_Tol &&    abs(vFreq-modeInfo.VerFreq)<VFreq_Tol &&
      	  (SrcFlags&0x13)==modeInfo.Flags)
      break;
    }

    if (i>=UserModeNumber)
    {
        g_PcSetting.SavedModeIndex=(g_PcSetting.SavedModeIndex+1)%UserModeNumber;
        g_ucSaveIndex=g_PcSetting.SavedModeIndex;
        modeInfo.HorFreq=hFreq;
        modeInfo.VerFreq=vFreq;
        modeInfo.Flags=SrcFlags&0x13;
        NVRam_WriteTbl(nvrModeInfoAddr(g_ucSaveIndex), (BYTE*)&modeInfo, ModeInfoSize);
        NVRam_WriteByte(nvrModeAddr(checksum), 0);
        NVRam_WriteByte(nvrMonitorAddr(SavedModeIndex), g_PcSetting.SavedModeIndex);
    }
    else
        g_ucSaveIndex=i;
}

void ReadModeSetting(void)
{
    BYTE tempValue;
    if (UserModeFlag)
        GetModeSaveIndex();
    else
        g_ucSaveIndex=g_ucSrcModeIndex;

#ifndef TempMask
    NVRam_ReadByte(nvrModeAddr(checksum), &tempValue);
#endif

    if (tempValue==ModeCSValue)
    {
#ifndef TempMask
        NVRam_ReadTbl(nvrModeBaseAddr(g_ucSaveIndex), (BYTE*)&g_ModeSetting, ModeSettingSize);
#endif
    }
    else
    {
        InitModeSetting();
        SaveModeSetting();
    }

    CheckModeSettingRange();
}
#endif
//**************************************************************************************************************//
💿 文件大小 998 K
👤 上传用户 choatehou4
📂 所属分类单片机开发
🏷️ 相关标签

#KEILC #液晶电视 #内置 #51单片机
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -