#include<string.h>
#include "mtv412.c"
#include "048n01.h"
static unsigned char pdata XRAM[128] _at_ 0x0f00;
typedef unsigned char  uchar;
typedef unsigned int   uint;
typedef unsigned char  BYTE;

sfr          PCON=0x87;

sfr          IE=0xa8;
sbit         EA=IE^7;
sbit         IntEnable=IE^7;
sbit         EX0=IE^0;
sbit         ET0=IE^1;
sbit         EX1=IE^2;
sbit         ET1=IE^3;

sfr          IP=0xb8;      
sbit         PX1=IP^2;
sbit         PT0=IP^1;

sfr          TMODE=0x89;
   
sfr          TCON=0x88;
sbit         IT1=TCON^2;
sbit         TR0=TCON^4;
sbit         TF0=TCON^5;
sbit         IE1=0x8b;

sfr          TH0=0x8c;   
sfr          TL0=0x8a;

sfr          P1=0x90;
sbit         P1_3=P1^3;
sbit         P1_4=P1^4;
sbit         P1_5=P1^5;
sbit         P1_6=P1^6;
sbit         P1_7=P1^7;


/* =========================================================================================*/
uchar  CursorX=0,CursorY=0,SW;
bit    H_Size_OK=0, V_Size_OK=1, H_Position_OK=1, V_Position_OK=1, T1msFLAG=0, T256msFLAG=0;
bit    OSD_status=0;                                        //1= on, 0= off
bit    STOUT;
uchar bdata OSD_C17=0;
uchar IIC_counter,VCO,tp,HORR,Hfreq;
unsigned int H_start,H_end,V_start,V_end,Scanline;
unsigned int TimeCounter;
///////////////
uchar  KeyCounter=0;
//////////////
float idata Scale_LOW=2.3,Scale_HI=1.0,Kvp=10.67,Kvs=6.78,V_Offset_ref=51.78,Vpercent_ref=96.06,* Khs,* Hpercent_ref;
uchar idata byAutoAlignCmd,byAutoAlignData;
uchar pdata PRAM[128] _at_ 0x800;  //mtv412 is 0x800
//============== TDA4856 deflection definition================================================
#define Hsize       0x81
#define Hposition   0x87
#define Vsize       0x88
#define Vposition   0x8d
#define Vunit       0x01
#define H_flb_pol   0x01
//============================================================================================
#ifndef _show_
 #include "show.h"
#endif

//void  OSDBoxDemosl(uchar,uchar,uchar,uchar,uchar,uchar);
void  InitOSD();
void  SendMtv212(uchar);
void  InitOSD31();
void  InitOSD47();
void  InitOSD63();
void  InitOSD95();
void  SendHORR(uchar,uchar,uchar,uchar,uchar);
void  ShowCharDemos();
void  Char_demo();
void  Showsymboladdr();
void  AnyKeyExit();
void KeyControl();
void Frame_keycontrol();
//void  InitOSD();
void  TurnOSD(bit status);
//void  Initmoudletest31();
void  AdjustVCO();
void  AdjustHORR();
//void  ShowAdjustVCOMenu();
//void  CloseAllOSDWindow();
void  ShowVCOBoard();
void  ShowHORRBoard();
void  PrintHex(uchar,uchar);
void  PrintDecCode(uchar,uchar);
void  ResetKey();
void WaitKeyup();
void  ShowSecondModuleTest();
//void  ShowMYSONInfo();
void  PrintString(uchar *,uchar ,uchar );
void  ShowSecondMenu();
 bit   SendIIC(uchar  *,uchar );
void  PutChar(uchar , uchar );
void Putuserchar(uchar da, uchar color);
void  CloseOSDWindow(uchar );
void  ClearOSD();
void  SendOSDCmd(uchar, uchar,uchar);

void AutoDemo();
void SingleDemo(uchar);
void ShowallfontDemo();
void Frame_shadow();
void Frame_toggle();
void  ShowMain();
void  ShowOSDAllFont(uchar);
void  PutPage2Char(uchar , uchar );
void  InitialUserFont();
//void  SendUserFontCmd(uchar,uchar,uchar);
void  ShowEnterISPmode();
void  ShowVCOHORR();
void Showtest31();
void Showtest47();
void Showtest63();
void Showtest95();
uchar PressKey();
//void  Initmoudletest31();


uchar code UserFont[]={
         0x00,0x70,
         0x01,0x80,
         0x02,0x40,
         0x04,0x40,     
         0x08,0x40,
         0x08,0xc0,
         0x10,0xe0,
         0x10,0xe0,
         0x11,0xe0,
         0x11,0xa0,
         0x11,0x00,
         0x13,0x10,
         0x0a,0x00,
         0x0a,0x00,
         0x04,0x00,
         0x02,0x00,
         0x01,0x80,
         0x00,0x70
         };
uchar code Upfont[]={
         0x00,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00,
         0x06,0x00,
         0x0f,0x00,
         0x1f,0x80,
         0x3f,0xc0,
         0x7f,0xe0,
         0x0f,0x00,
         0x0f,0x00,
         0x0f,0x00,
         0x0f,0x00,
         0x0f,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00
         };
uchar code Downfont[]={
         0x00,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00, 
         0x0f,0x00,
         0x0f,0x00,
         0x0f,0x00,
         0x0f,0x00,
         0x0f,0x00,
         0x7f,0xe0,
         0x3f,0xc0,
         0x1f,0x80,
         0x0f,0x00,
         0x06,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00
        };

uchar code Leftfont[]={
         0x00,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00,
         0x04,0x00,
         0x0c,0x00,
         0x1c,0x00,
         0x3f,0xe0,
         0x7f,0xe0,
         0x7f,0xe0,
         0x3f,0xe0,
         0x1c,0x00,
         0x0c,0x00,
         0x04,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00
         };
uchar code Rightfont[]={
         0x00,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00,
         0x02,0x00,
         0x03,0x00,
         0x03,0x80,
         0x7f,0xc0,
         0x7f,0xe0,
         0x7f,0xe0,
         0x7f,0xc0,
         0x03,0x80,
         0x03,0x00,
         0x02,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00,
         0x00,0x00
         };


bit   KeySelect1=0;
bit   KeySelect2=0;
bit   KeySelect3=0;
bit   KeySelect4=0;
bit   KeySelect5=0;
bit   KeySelect6=0;
bit   KeyLayer1=1;
bit   KeyLayer2=0;
bit   KeyLayer3=0;
bit   KeyLayer4=0;
bit   MainMenuFlg=0;
bit   SecondMenuFlg=0;
bit   ThirdMenuFlg=0;
bit   SingleOSDflag=0;//the flag sign man choose singledemo or autodemo
bit   Frame_nextflag=0;

uint  Exitflag=0;
uchar KeyP=0;
uint  Showsymbol=0;

uchar chh=0x30;         
uchar h_del=0x02;
uchar v_del=9;
uchar rspace=0x00;
uchar vcom=0x1;        //12*16 fonts and VCO=(0,1)
uchar horrm=0x27;      //for moudletest


static uchar HORRAddDec=62;       //for normal
static uchar VCOAddDec=0x02;
static bit  ChangeHORRflag=0;//in order to solve the font dots move problem
static uchar VertPosition=36;
static uchar HorrPosition=42;

//static uchar VertPosition=27;
//static uchar HorrPosition=47;
static uchar ChHeight=0x05;
static uchar Test_Chhigh=0x31;//when the frequency higher ,the movement and the character height may not be enough for test
static uchar Test_Rowhigh=0x0c;
static uchar Test_Movedown=0x45;

static uchar Freqflag=2;//2--47khz
static uchar HORRflag=1;  //indicate the HORR
/*============== TDA4854 deflection definition================================================
#define Hsize       0x00
#define Hposition   0x06
#define Vsize       0x08
#define Vposition   0x02
#define Vunit       0x02
#define H_flb_pol   0x00
============================================================================================ */
void   gotoxy(uchar , uchar );
//void   print(uchar  *, uchar );
void   delay(unsigned int );
void   delay_short(unsigned int );
//void   ReadHsync();
//bit    KeyPressed();
//void   PutHex(uchar  , uchar  );
void   OpenOSDWindow(uchar  ,uchar  ,uchar  , uchar  , uchar  , uchar  ,bit );
//uchar  GetKey();

//============================================================================================

void SendUserFontCmd(uchar row,uchar column,uchar value)
{
  uchar buf[4];

  buf[0]=0x7a;
  buf[1]=row|0xc0;
  buf[2]=column|0x40;
  buf[3]=value;
  SendIIC(buf,4);
}

void InitialUserFont()
{
  uchar i,j;
  
  for(j=0;j<36;j++)
  	{
  	SendUserFontCmd(0,j,Upfont[j]);
  	}
  for(j=0;j<36;j++)
  	{
     SendUserFontCmd(1,j,Downfont[j]);
    }
  for(j=0;j<36;j++)
  	{
     SendUserFontCmd(2,j,Leftfont[j]);
    }
  for(j=0;j<36;j++)
  	{
     SendUserFontCmd(3,j,Rightfont[j]);
    }
  
  for(i=4;i<8;i++)
  {
   for(j=0;j<36;j++)
   {
    SendUserFontCmd(i,j,UserFont[j]);
   }
  }
}

void PutPage2Char(uchar  da, uchar  color)
{
   uchar  buf[4];
 
   buf[0]=0x7a;
   buf[1]=CursorY|0x80;
   buf[2]=CursorX|0x20;	// or 0x20 is the page2 font
   buf[3]=da;
   SendIIC(buf,4);
      
   buf[1]|=0xa0;
   buf[3]=color; 
   SendIIC(buf,4);

   CursorX++;
   if(CursorX>29)
   {
    CursorX=0;
    CursorY++;
   }
   if(CursorY>14) 
    CursorY=0; 
}
void ShowOSDAllFont(uchar ifInitflag)
{
  int i=0,j=0;
  
  ResetKey();
  ClearOSD();
  //Initmoudletest();
  OpenOSDWindow(1,0,1,29,13,cyan,0);
  OpenOSDWindow(2,0,0,29,14,yellow,0);
  gotoxy(8,0);
  for(i=0;i<13;i++)
   PutChar(OSDFontall[i],7);
  gotoxy(16,14);
  for(i=0;i<14;i++)
   PutChar(AnyKeyAway[i],7);
  gotoxy(0,1);
  for(i=0;i<256;i++)
   {
    if(i%30==0)
     {
      j++;
      if(j==3) j++;
      if(j>=8) j=1;                   //omit black
     }
    PutChar(i,j);
    
   }
  for(i=0;i<128;i++)
   {
    if((i+16)%30==0)
     {
      j++;
      if(j==3) j++;
      if(j>=8) j=1;
     }
    PutPage2Char(i,j);
   }
  ResetKey();	
 do
 {
  AnyKeyExit();
  KeyLayer2=0;
  KeyLayer1=1;
  MainMenuFlg=1;
  WaitKeyup();//**************
  ClearOSD();
  if(ifInitflag==1)
  {
	 InitOSD();
  }
  TurnOSD(1);
 }while(KeyLayer2!=0 );
  SecondMenuFlg=0;
  MainMenuFlg=1;
 //InitOSD63();
 //TurnOSD(1);     
}
void ShowEnterISPmode()
{
  ClearOSD();
  ResetKey();
  OpenOSDWindow(3,6,4,21,9,cyan,0);
  gotoxy(9,6);
  PrintString(ShowISP,11,red);
  while(1)
  {  
  }
}
// Handler for Interrupt # 1
void int1 (void) interrupt 2
{                         
 uchar INTFLG,temp;   // static int i=0;			//[Bosan]3/8
  EA=0; 
   INTFLG=XRAM[IIC_INTFLG]; 
 
 if( ( XRAM[IIC_INTFLG]&0x20) !=0 )                          // Slave B matched   for ISP
     {                                 
        XRAM[IIC_INTFLG]=INTFLG&0x08;                 // 00000101b, Clear interrupt flag 
      }
       // if( ( INTFLG&0x40 ) !=0 )                     // Receieved data
       //   {
	
	if( (XRAM[IICSTUS]&0x80 ) !=0) // if( (XRAM[IICSTUS1]&0x80 ) !=0)     
        {
             
      	  temp=XRAM[RCBBUF];  // i++; 
      
       	  if((XRAM[IICSTUS]&0x08)!=0)  //if((XRAM[IICSTUS1]&0x08)!=0)
           {  
       	       
	      if(temp==0x1f)    
             {
                                     
               IE=0;
                XRAM[WDT]=0;
                XRAM[ISPSLV]=0x94;
                XRAM[ISPEN]=0x93;
                PCON=1;                    
              }  
        }  }
      // else 
      //   byAutoAlignData=XRAM[RCBBUF];
      // }
// IE1=0;                         
EA=1;                                              
           
 }

void int0 (void) interrupt 0
{
}
// Handler for timer 0 in 1ms timebase interrupt
void timer0 (void) interrupt 1
{
   EA=0;
   T1msFLAG=1;
   KeyCounter++;
   TimeCounter++;
   IIC_counter++;
   KeyP=PressKey();      //when timer interrupts,check if key is being pressed
   if(TimeCounter==0)
    { T256msFLAG=1;}
   //if(Showsymbol==1)
    //{ Showsymboladdr();}
   TH0=TH0+0xfc;
   TL0=TL0+0x18;
   EA=1;
}

// Wait for MBUFL flag and clear it, return 1 if time out
bit wait_IIC()
{
   bit err=0;
 
   IIC_counter=0;
   while( (XRAM[IIC_INTFLG]&0x1)==0)                 // Wait for MBUFl                  
   {
    if(IIC_counter>2)
     {
      err=1;
      break;
     }
    }
 
    if( ( XRAM[IICSTUS] & 0x01 )  != 0 )             // No Ack receieved from IIC slave device 
      err=1;                                                   

   XRAM[IIC_INTFLG]=0;

   return(err); 
}

void InitMicroP()
  {
   // Set IIC speed to 200 kHz
   XRAM[OPTION]=0x82;   //MTV412                               // Select 400 kHz , Disable DDC2 bypass mode
   //XRAM[OPTION1]=0;                                  // Select 200 kHz , Disable DDC2 bypass mode
   XRAM[IIC_INTEN]=0xe0;
   //XRAM[SLVA1ADR]=0x00;  //0;
   XRAM[SLVA2ADR]=0x00;
   XRAM[SLVBADR]=0x80|(0xc6>>1);
   // Set P3.0, P3.1, P3.4, p3.5 to IIC related pins
   XRAM[PADMOD0]=0x00;                                 
   XRAM[PADMOD1]=0x7f;                                 
   XRAM[PADMOD2]=0xe7;
   XRAM[PADMOD3]=0x7f;
   XRAM[PADMOD4]=0x0ff;
   XRAM[PADMOD5]=0x00;
   XRAM[PADMOD6]=0x1f;
   XRAM[PADMOD7]=0x00;                               // Use HSCL, HSDA, ISCL, ISDA  
   XRAM[HVSTUS]|=0xe0;	// enable composite 
   XRAM[HV_INTEN]=0X01;                                  // Disable all H/V sync related interrupt 
   //XRAM[HVCTR2]=0x21;                                 // Disable Self-Pattern out.
//XRAM[ISPCMP1]=0X00;
//XRAM[ISPCMP2]=0X00;
//XRAM[ISPCMP3]=0X00; 
  
  //XRAM[XBANK]=0;
  // XRAM[ADC]=0x8f;
   // Set Time Base=1ms 
   TH0=0x0fc;
   TL0=0x18;
   IT1=0;
   TMODE=0x51;                                        // Set Timer1=counter , Timer0=timer
   TR0=1; 
   IE=0x86;                                           // Enable timer 0 and interrupt 1
   
   P1=0x0ff;                                   // Set all bits in P1 to 1
   }


void delay_short(unsigned int time)
{
   unsigned int i;
   for(i=0;i<time;i++);
}

void delay(unsigned int time)        //based on 1ms
{
   TimeCounter=0;
   while (TimeCounter!=time)
   { 
   }  
}
// Send n byte(s) of IIC data stored in the *buf 
// Retrun value: 0 =normal, 1= error
bit SendIIC(uchar  *buf,uchar  n)
{
   uchar  i=0;
   bit err=0; 
   XRAM[IIC_INTFLG]=0;                               // Clear MBUFl
   XRAM[MBUF]=buf[i];                                // First byte of IIC data
   XRAM[IICCTR]=0;                                   // P=0; Keep S low
   delay_short(2);
   XRAM[IICCTR]=1;                                   // S now rising
   delay_short(2);

   for(i=1; i<n;i++)
     {                                                        
      IIC_counter=0;
      
      err=wait_IIC(); 

      if(err==1)
         break; 
      
      XRAM[MBUF]=buf[i];                             // Send next byte
      delay_short(4);
      } 
   XRAM[IICCTR]=0;
   XRAM[IICCTR]=0x2;                                 // P rise, S low, Stop transmitting