ini.c

一个多媒体液晶显示器内部控制器(主芯片为:7301)的源程序(KC51

/*
   --------------------------------------------------------------
   file name          : INI.C
   author             : ccchen
   date               : 910315
   version number     : v3_cc910315.1
   brief introduction : system initial file
   reversion history  : v3_cc910314.1
   --------------------------------------------------------------
*/

#include"CORE_LIB.H"
#include"EEPROM.H"
#include"MENUITEM.H"
#include"OSD_LIB.H"
#include"PROCESS.H"
#include"STATE.H"
#include"USER.H"

//extern unsigned char WarmReset;
extern bit UltCheckContinueKey(void);

unsigned char code CORE_VERSION_TABLE[4]=
{0x02,0x11,0x14,0x02};

unsigned char code OSD_VERSION_TABLE[4]=
{0x02,0x04,0x24,0x01};

unsigned char code FIRMWARE_VERSION_TABLE[4]=
{0x00,0x00,0x00,0x01};

unsigned char code BURN_TYPE_TABLE[1]=
{0x00}; // disable

// R_gain, G_gain, B_gain, R_offset, G_offset, B_offset, back light
unsigned char code ADC_GAIN_OFFSET_TABLE[7]=
{0xa0,0xa0,0xa0,0x80,0x80,0x80,0x00};

unsigned char code ADC_GAMMA_TABLE[][5]=
{ // R gamma,G gamma,B gamma,brightness,contrast
  {46,50,42,50,50} // 6500
 ,{50,50,33,50,50} // 9300
 ,{50,50,50,50,50} // AUTO
 ,{50,50,50,50,50} // USER
};


unsigned char code USER_DATA_TABLE[20]=
{
  0x00 // text/graphic (text)            [0]
 ,0x00 // mute (mute enable)            [1]
 ,0x03 // color temperature (user)      [2]
 ,0x00 // transparancy enable (disable) [3]
 ,0x03 // transparancy_R                [4]
 ,0x03 // transparancy_G                [5]
 ,0x03 // transparancy_B                [6]
 ,0x10 // sharpness                     [7]
 ,0x00 // language (English)            [8]
 ,0x00 // OSD H position hi byte        [9]
 ,0x00 // OSD H position low byte       [10]
 ,0x00 // OSD V position hi byte        [11]
 ,0x00 // OSD V position low byte       [12]
 ,0x03 // OSD off time hi byte          [13]
 ,0x10 // OSD off time low byte         [14]
 ,0x00 // volume hi byte                [15]
 ,0xFF // volume low byte               [16]

 ,0xFF // trebel                        [17]
 ,0xFF // base                          [18]
 ,0x00 // source type                [19]
};

//extern void ReStart();

unsigned char ScanKey(unsigned char STATUS)
{
  bit QUIT=FALSE;
  unsigned char KEY=0;
  unsigned int idata OSDtimer=0;

  MODEchange=FALSE;
  while (!QUIT)
  {
    if   (POWERstate==ON)
         {
           if   (ModeChanged(UsrSourceType()))
                {
                  MODEchange=QUIT=TRUE;
                  BACKLIGHT=DARK;
                  OsdOnOffSet(OFF);
                  if (POWERsaving)
                     {
                       POWERsaving=FALSE;
                       Initial(); 
                     }
                  if (NOsync)
                     {
                       ReadUserAdcOffsetFromEeprom();
                       ReadUserColorTemperatureFromEeprom();
                     }
                } // end of if (ModeChanged())
           else { // (!ModeChanged())
                  if   (KeyReady())
                       {
                         KEY=GetKey();
                         if   ((KEY==POWERkey)&~UltCheckContinueKey())
                              {
                                ProcessPowerState(OFF);
                                QUIT=TRUE;
                              }
                         else {
                                if (STATUS!=NO_SYNC_STATUS)
                                   QUIT=TRUE;    
                              }
                       } // end of if (KeyReady())
                  if (!QUIT)
                     {
                       if   (STATUS!=NO_SYNC_STATUS)
                            {
                              if (OSDtimer>USER_DATA.OSDoffTIME)
                                 { 
                                   QUIT=TRUE;		
                                   //UserOff();
                                   INTERFACE=NOinterface;
                                   OsdOnOffSet(OFF);       
                                 }
                            } // end of if (STATUS!=NO_SYNC_STATUS)
                       else { // (STATUS==NO_SYNC_STATUS)
                              if ((OSDtimer>0x0014)&&(POWERsaving==FALSE))
                                 {
                                   QUIT=TRUE;				
                                   OsdOnOffSet(OFF);       
                                   POWERsaving=TRUE;
                                   UltPowerSaving();
                                   PowerOffSequency();
                                 }
                            }
                     } // end of if (!QUIT)
                } // end of else // (!ModeChanged())
           if (POWERsaving==FALSE)
              { 
                ++OSDtimer;
                Wait1ms(30);
              }
         } // end of if (POWERstate==ON)
    else {
           if   (KeyReady())
                {
                  KEY=GetKey();
                  if ((KEY==POWERkey)&~UltCheckContinueKey())
                     {  
                       //ProcessPowerState(ON);
                       PROCESS_POWER(ON);
                       QUIT=TRUE;
                       Wait1ms(100);
//                     WarmReset=0xa5;
//		       		   ReStart(); // Addd by Liu 1115
                     } // end of if (KEY==POWERkey)
                } // end of if (KeyReady())
         } // end of else ...
  } // end of while (!QUIT&&!B_OSDoff)
  return KEY;
}

void ReadUserAdcOffsetFromTable()
{

  // ADC gain
  // -----------------------------------------------
  UltGainSetting(SETmode,Rkind,ADC_GAIN_OFFSET_TABLE[0]);
  UltGainSetting(SETmode,Gkind,ADC_GAIN_OFFSET_TABLE[1]);
  UltGainSetting(SETmode,Bkind,ADC_GAIN_OFFSET_TABLE[2]);
  // -----------------------------------------------

  // ADC offset
  // -------------------------------------------------
  UltOffsetSetting(SETmode,Rkind,ADC_GAIN_OFFSET_TABLE[3]);
  UltOffsetSetting(SETmode,Gkind,ADC_GAIN_OFFSET_TABLE[4]);
  UltOffsetSetting(SETmode,Bkind,ADC_GAIN_OFFSET_TABLE[5]);
  // -------------------------------------------------
}

/*
void ReadUserAdcGainFromTable()
{
  unsigned char COLORtemperature=GetColorTemperature();

  // red 
  UltGainSetting(
                 SETmode,Rkind
                 ,ADC_GAIN_TABLE[COLORtemperature][Rkind]
                );

  // green
  UltGainSetting(
                 SETmode,Gkind
                 ,ADC_GAIN_TABLE[COLORtemperature][Gkind]
                );

  // blue
  UltGainSetting(
                 SETmode,Bkind
                 ,ADC_GAIN_TABLE[COLORtemperature][Bkind]
                );

  // brightness
  USER_DATA.BRIGHTNESS=ADC_GAIN_TABLE[COLORtemperature][3];

  // contrast
  USER_DATA.BRIGHTNESS=ADC_GAIN_TABLE[COLORtemperature][4];

  SetGamma();
} // end of function ReadUserAdcGainFromTable()
*/

void ReadUserGammaFromTable()
{
  unsigned char COLORtemperature=GetColorTemperature();

  // R gamma
  USER_DATA.Rgamma=ADC_GAMMA_TABLE[COLORtemperature][0];

  // G gamma
  USER_DATA.Ggamma=ADC_GAMMA_TABLE[COLORtemperature][1];

  // B gamma
  USER_DATA.Bgamma=ADC_GAMMA_TABLE[COLORtemperature][2];
  
  // brightness
  USER_DATA.BRIGHTNESS=ADC_GAMMA_TABLE[COLORtemperature][3];

  // contrast
  USER_DATA.CONTRAST=ADC_GAMMA_TABLE[COLORtemperature][4];

  SetGamma();
}


void ReadUserDataFromTable()
{
  bit STATE= (USER_DATA_TABLE[0]) ? GRAPHICmode : TEXTmode;
  unsigned char DATA;
  unsigned int  VALUE;

  // text/graphic
  // ******************************************************
  SetTextGraphic(STATE);
  // ******************************************************

  // mute
  // ******************************************************
  STATE= (USER_DATA_TABLE[1]) ? ENABLE : DISABLE;
  SetMute(STATE);
  // ******************************************************

  // color temperature
  // ******************************************************
  SetColorTemperature(USER_DATA_TABLE[2]);
  // ******************************************************

  // transparency enable
  // ******************************************************
  STATE= (USER_DATA_TABLE[3]) ? ENABLE : DISABLE;
  SetMute(STATE);
  // ******************************************************


  // sharpness
  // ******************************************************
  UltSharpnessSetting(SETmode,USER_DATA_TABLE[7]);
  // ******************************************************

  // language
  // ******************************************************
  USER_DATA.LANGUAGE=USER_DATA_TABLE[8];
  // ******************************************************

  // OSD h position
  // ******************************************************
  VALUE=USER_DATA_TABLE[9];
  VALUE<<=8;
  VALUE+=USER_DATA_TABLE[10];
  USER_DATA.OSDhPOSITION=VALUE;
  // ******************************************************

  // OSD v position
  // ******************************************************
  VALUE=USER_DATA_TABLE[11];
  VALUE<<=8;
  VALUE+=USER_DATA_TABLE[12];
  USER_DATA.OSDvPOSITION=VALUE;
  // ******************************************************

  // OSD off time
  // ******************************************************
  VALUE=USER_DATA_TABLE[13];
  VALUE<<=8;
  VALUE+=USER_DATA_TABLE[14];
  USER_DATA.OSDoffTIME=VALUE;
  // ******************************************************

  // volume
  // ******************************************************
  VALUE=USER_DATA_TABLE[15];
  VALUE<<=8;
  VALUE+=USER_DATA_TABLE[16];
  USER_DATA.VOLUME=VALUE;
  // ******************************************************

  // trebel
  // ******************************************************
  DATA=USER_DATA_TABLE[17];
  USER_DATA.TREBEL=DATA;
  // ******************************************************

  // base
  // ******************************************************
  DATA=USER_DATA_TABLE[18];
  USER_DATA.BASE=DATA;
  // ******************************************************

  // source type
  // ******************************************************
  DATA=USER_DATA_TABLE[19];
  SetSourceTypeFlag(DATA);
  // ******************************************************
}

void ReadUserFromTable()
{
  ReadUserAdcOffsetFromTable();
  ReadUserGammaFromTable();
  ReadUserDataFromTable();
}

void InitialOsd(unsigned int Xstart,unsigned int Ystart)
{ 
  unsigned int Xwidth=256,Ywidth=218;

  OsdLoadValue(0,0,0,0,0);
  OsdResolutionSet(16);
  OsdScreenClear(0);			
  OsdXYDimSet(OSDwidth,OSDheight);		//mem(x,y) x=N*8, y=M*4
  UltOsdPositionSetting(Xstart,Ystart);		//osd win(x,y)
  OsdTransparentSet(1,1);                     //
  OsdSubwinOnOffSet(0,1);                  //(win_no,enable)
  OsdSplitWinSet(0,0,0,0);              //(Xsplit,Ysplit,StartX,StartY
  OsdTransparentStyleSet(2,2,2);                 //
  OsdBlinkDutySet(2);                   //
  OsdBlinkStyleSet(0,0,0);              //  		
  OsdSubwinPosSet(0,0,0,Xwidth,Ywidth);        //(win_no,start_x,start_y,end_x,end_y)
  OsdDispStartLocationSet(0,0);
}

/*
void InitialEeprom()
{
  UltEnPseudoMode();
  PROMPT(InitialEeprom_STRING,YELLOW);
  WriteEepromFromTableToFactory(); 
  CopyEepromFromFactoryToUser();
  Wait1ms(0x1111);
  OsdOnOffSet(OFF);
  PowerOffSequency();
  UltDisPseudoMode();	
}
*/

void InitialEeprom()
{
  UltEnPseudoMode();
  Prompt(INITIAL_EEPROM_STRING,YELLOW);
  //UltEraseEEprom();
  UltEraseMode();
  WriteEepromFromTableToFactory(); 
  CopyEepromFromFactoryToUser();
  OsdOnOffSet(OFF);
  PowerOffSequency();
  UltDisPseudoMode();	
}


void InitialProcess()	
{
  bit LIBRARYerror=FALSE,EEPROMerror=FALSE,FIRMWAREerror=FALSE;

  if (CheckLibraryVersion()==FALSE) 
     LIBRARYerror=TRUE;
  InitialEepromState();
  if   (GetEepromState()==VALID)
       {
         ReadPowerStateFromEeprom();
         if (CheckFirmwareVersion()==FALSE)
            FIRMWAREerror=TRUE;
         ReadUserFromEeprom();
       }
  else EEPROMerror=TRUE;
  if   (POWERstate==OFF)
       { 
         ProcessPowerState(OFF); 
         while (POWERstate==OFF)
         {
           if   (KeyReady())
                {
                  if (GetKey()==POWERkey)
                     ProcessPowerState(ON); 
                }
         } // end of while (POWERstate==OFF)
       } // end of if (POWERstate==OFF)  
  if (LIBRARYerror) // library unmatch
     ProcessPrompt(LIBRARY_UNMATCH_STRING,CYAN); 
  if (FIRMWAREerror) // firmware unmatch
     {InitialEeprom(); 
      ReadUserFromEeprom();}
  else if (EEPROMerror)
     { // EEPROM invalid
       ProcessPrompt(EEPROM_ERROR_STRING,RED); 	 
       ReadUserFromTable();
     }
  InitialOsd(USER_DATA.OSDhPOSITION,USER_DATA.OSDvPOSITION);
}