ksr810.c

PIC单片机上用C语言写的TW88TFT屏控制程序,有注释

/*        InitWindow4                             */
/*function : initialize window4 registers         */
/*input : none                                    */
/*output : none                                   */ 
/**************************************************/
void InitWindow4(void)
{
 unsigned char window_val[NB_WINOPTION];
   
  //use Multi-write function
   InitTable(window_val, NB_WINOPTION); 
    window_val[0]  = WIN4;
    window_val[1]  = HSTART4;
    window_val[2]  = VSTART4;
    window_val[3]  = WINW4;
    window_val[4]  = WINH4;
    window_val[5]  = BOR4;
    window_val[6]  = BORH4;
    window_val[7]  = BORV4;
    window_val[8]  = HSPACE4;
    window_val[9]  = VSPACE4;
    window_val[10] = ADDSTART4;
    MWriteI2C(TW88, WINDOW4, window_val, NB_WINOPTION);
   
/*
    WriteI2C(TW88, WINDOW4, WIN4);
    WriteI2C(TW88, W4_HSTART, HSTART4);
    WriteI2C(TW88, W4_VSTART, VSTART4);
    WriteI2C(TW88, W4_WIDTH, WINW4);
    WriteI2C(TW88, W4_HEIGHT, WINH4);
    WriteI2C(TW88, BORDER4, BOR4);
    WriteI2C(TW88, B4_H , BORH4);
    WriteI2C(TW88, B4_V, BORV4);
    WriteI2C(TW88, W4_HSPACE, HSPACE4);
    WriteI2C(TW88, W4_VSPACE, VSPACE4);
    WriteI2C(TW88, W4_ADDSTART, ADDSTART4);
*/ 
}

/**************************************************/
/*        DisplayW4                               */
/*function : Display window4                      */
/*input :  const char *text                       */
/*output : none                                   */ 
/**************************************************/
void DisplayW4(const char *text)
{
    char direction[]=" PICTURE DIRECTION ";
    cnt = 0;
    addstart = ADDSTART4;
    win_size = SIZE4;
    font_op = FONT4;

    INTE=0;           
    
    //write text to display on window4
    putst(direction);
    putst(text);
    INTE=1;
    WriteI2C(TW88, W4_WIDTH, cnt); //set Window1 width 
    WriteI2C(TW88, WINDOW4, WIN4 | 0x01); //enable window4      
}




/**************************************************/
/*        putst                                    */
/*function : put a text in the OSD RAM            */
/*input :  const char *tx                         */
/*output : none                                   */ 
/**************************************************/
void putst(const char *tx)
{
      WriteI2C(TW88, FONT_SELECT, ROM | 0x01); //Select font from rom
                                           //Enable OSD RAM access                                             
       while( (*tx)!=0 )
       {
            putch(addstart+cnt, (*tx));                   
            cnt++;
            tx++;
        }
        WriteI2C(TW88, FONT_SELECT, ROM); //disable OSD RAM access 
}

/**************************************************/
/*        putch                                    */
/*function : put a character in the OSD RAM       */
/*input :  unsigned char add, unsigned char font  */
/*output : none                                   */ 
/**************************************************/
void putch(unsigned char add, unsigned char font)
{
    WriteI2C(TW88, FONT_RAM, add); //font address in the ram 
    //code of the character to display (TW8801 datasheet p15)
    WriteI2C(TW88, FONT_OUT, font); 
    //Attribute of characters (TW8801 datasheet p19)
    WriteI2C(TW88, FONT_OPTION, font_op); //character bleu  
}

/**************************************************/
/*        comp2                                   */
/*function : convert input into complement2 value */
/*input : unsigned char data                      */
/*output : unsigned char                          */ 
/**************************************************/
unsigned char comp2(unsigned char data)
{
    data^=0xff; // complement1 : invert bit
    data++; // comp1(data)+1=comp2(data)
    return(data); 
}

/**************************************************/
/*        Conv10                                  */
/*function : Convert the binary integer (8bits)   */
/*           into a number in base 10             */
/*           and place result in ASCII value      */
/*           in the table "number10"              */
/*           if "sign" = 1 => value is comp2      */
/*input :  unsigned char value,                   */
/*         unsigned char number10*                */
/*output : void                                   */ 
/**************************************************/
void Conv10(unsigned char value, unsigned char *number10)
{
    unsigned char i = 0;
    unsigned char chiffre = 0;
    
    InitTable(number10, NUM10_MAX ); 
   
    while(value>=10)
    {
        value-=10;
        chiffre++;
    }
    number10[i] = chiffre + '0';
    i++;
    number10[i] = value + '0';
}

/**************************************************/
/*       ConvVal                                  */
/*function : convert mode chosen value            */
/*           between 0-63                         */
/*input :  void                                   */  
/*output : unsigned char                          */ 
/**************************************************/
unsigned char ConvVal(void)
{
    unsigned char value = 0; //value to display

     switch(choix)
    {
        case 1 : value = bght;
                 if((value>128)&&(value<=208))
                 {
                     value^=0x80; //value<0 value=128-|value| 
                                  //value>=0 value+=128 

                     value/=2; 
                     value-=8;
                 }
                 else
                 {
                     value^=0x80;
                     value/=5;
                     value+=16;
                 }              

                 break; 
      
        case 2 : value = ctst;
                 if(value<=108)
                 {
                         value^=0x00;
                         value/=3;
                         value-=4;
                 } 
                 else
                 {
                         value^=0x00;
                         value/=4;
                         value+=5;
                 }
                 break;
         
        case 3 : value = color;
                  if(value<=160)
                 {
                         //value^=0x00;
                         value/=5;
                         value-=0;
                 } 
                 else
                 {
                         //value^=0x00;
                         value/=3;
                         value-=21;
                 }
                 break;
                  
                      
        default : break;
    }
    
        
    return(value);
}

/**************************************************/
/*        SetValBar                               */
/*function : set the table of value bar to display*/
/*                                                */
/*input : unsigned char *bar, unsigned char val   */  
/*output : void                                   */ 
/**************************************************/
void SetValBar(unsigned char *bar, unsigned char val)
{
    unsigned char i;
    
    if(val<3)
    { 
        for(i=0;i<BAR_MAX-1;i++)
            bar[i] = 0x01;  // '..'
    }      

    else if(val>59)
    {
             for(i=0;i<BAR_MAX-1;i++)
                 bar[i] = 0x04;  // '||'
    }
    else
    {
          if((val%2)==1)  //if odd
          {       
              val>>=1; //val/=2;
              val-=1;
              bar[val] = 0x02; // '|.'
          }        
          else
          {
              val>>=1; //val/=2;
              val-=1;
              bar[val] = 0x01; // '..' 
          }  
          
          for(i=0;i<val;i++)
              bar[i] = 0x04;  // '||'
          for(i=val+1;i<BAR_MAX-1;i++)
              bar[i] = 0x01;  // '..'
    }
    bar[BAR_MAX-1]=0; //stop
}

////////////////////////////////////////////////////
//            LCD Panel functions                 //
////////////////////////////////////////////////////

/**************************************************/
/*         PanelClock                             */
/*function : initialize Panel clock               */
/*input : none                                    */
/*output : none                                   */ 
/**************************************************/
/*void PanelClock(void)
{
    unsigned int fbdiv; //feed back divider value
    unsigned char factor=2;

    WriteI2C(TW88, PLLCON, PLLCON_VAL);
    WriteI2C(TW88, PLLS, PLLS_VAL);
    WriteI2C(TW88, REFDM, REFDM_VAL);

    // (REFDM+1)*2^PLLS => (REFDM+1)*(2<<(PLLS-1))
    if(!PLLS_VAL)
        factor=1;
    else 
        factor<<=(PLLS_VAL-1);
    
    fbdiv = (REFDM_VAL+1)*factor; 
    
    fbdiv = fbdiv*P_CLK/TWCLK; 
    fbdiv--;
    //set feed back divider registers
    WriteI2C(TW88, FBDN_LO,(fbdiv&0x00ff));
    fbdiv>>=8;
    fbdiv&=0x0F; //fbdn_hi : 4bits 
    WriteI2C(TW88, FBDN_HI,(0x20|fbdiv));
}  
*/

/**************************************************/
/*        BOOT_SHARP                              */
/*function : initialize TW88 register for         */
/*          SHARP VGA panel (default : NTSC )     */    
/*input : none                                    */
/*output : none                                   */ 
/**************************************************/
void BOOT_SHARP(void)
{
    unsigned char multi[DATA_MAX]; //multi write table 
    
    //InitTable(multi, DATA_MAX);
    
    //SDT
    WriteI2C(TW88, 0x1c, 0x0F); //auto, disable shadow
    
    //GAMMA
    WriteI2C(TW88, 0x04, 0x00); //disable luminance gamma
 
    //dynamic allocation
    //unsigned char *multi;
    //multi = malloc(sizeof(unsigned char));  
    //multi = {0x12, 0x15, 0x20, 0xb1, 0xd0, 0xcc, 0x85};
    // MWriteTW88(0x07, multi, 7);
    //free(multi);
    
    //address 0x07-0x0d 
    //CROP_HI, VDELAY_LO, VACTIVE_LO, HDELAY_LO, HACTIVE_LO 
    //CNTRL1, 0x0D
    multi[0] = 0x12; //CROP_HI
    multi[1] = 0x15; //VDELAY_LO
    multi[2] = 0x20; //VACTIVE_LO
    multi[3] = 0xb1; //HDELAY_LO
    multi[4] = 0xd0; //HACTIVE_LO
    multi[5] = 0xcc; //CNTRL1
    multi[6] = 0x85; //0x0D
    MWriteI2C(TW88, 0x07, multi, 7);

    //address 0x20-0x31
    //CLMPG, IAGC, PEAKWT, CLMPL, SYNCT, MISSCNT, 
    //V_CNTRL1, V_CNTRL2, C_KILLER, COMB_FILTER, 
    //LUMA_DELAY&HSYNC, MISC1, MISC2, MISC3, CLMPC2
    multi[0] = 0x60; //CLMPG
    multi[1] = 0x82; //IAGC
    MWriteI2C(TW88, 0x20, multi, 2);

    multi[0] = 0xd0; //PEAKWT
    multi[1] = 0x3c; //CLMPL
    multi[2] = 0x38; //SYNCT
    multi[3] = 0x4a; //MISSCNT
    MWriteI2C(TW88, 0x23, multi, 4);

    multi[0] = 0x00; //V_CNTRL1
    multi[1] = 0x00; //V_CNTRL2
    multi[2] = 0xb0; //C_KILLER
    multi[3] = 0x16; //COMB_FILTER 
    multi[4] = 0x38; //LUMA_DELAY&HSYNC 
    multi[5] = 0x00; //MISC1
    multi[6] = 0x91; //MISC2
    multi[7] = 0xe6; //MISC3
    MWriteI2C(TW88, 0x28, multi, 8);

    WriteI2C(TW88, 0x31,0x14); //CLMPC2

    //0x40-0x44
    //input/output
    multi[0] = 0x00; //input
    multi[1] = 0x40; //output
    MWriteI2C(TW88, 0x40, multi, 2);
    //WriteI2C(TW88, 0x44, 0x18); //input control
    
    //0x5d-0x62
    //zoom
    multi[0] = 0x00; //H-scale up lo 
    multi[1] = 0x76; //V-scale up lo
    multi[2] = 0x00; //H-scale dn lo
    multi[3] = 0x05; //H/V scale up/dn hi
    multi[4] = 0x00; //H-scale up offset
    multi[5] = 0x73; //V-scale up offset
    MWriteI2C(TW88, 0x5d, multi, 6);
    
    //0x64-0x6c
    //color adjust
    /*multi[0] = 0x80; //R contrast
    multi[1] = 0x80; //G contrast
    multi[2] = 0x80; //B contrast
    multi[3] = 0x80; //R brightness
    multi[4] = 0x80; //G brightness
    multi[5] = 0x80; //B brightness
    multi[6] = 0x00; //Sharpness
    multi[7] = 0x00; //zigzag
    multi[8] = 0x00; //zigzag, edge
    MWriteI2C(TW88, 0x64, multi, 9); */   

    //0xa2-0xaf
    //display control

    multi[0] = 0x00; 
    multi[1] = 0x11; //output VSYNC delay from input VSYNC
    multi[2] = 0x0d; //FPVS period lo
    multi[3] = 0x02; //FPVS active pulse width
    multi[4] = 0x21; //FPV back porch width
    multi[5] = 0xe0; //FPV active length lo
    multi[6] = 0x12; //FPV active length hi/FPVS period hi
    multi[7] = 0xcb; //FPHS period lo
    multi[8] = 0x10; //FPHS active pulse width
    multi[9] = 0x30; //FPH back porch width
    multi[10] = 0x80; //FPDE horizontal Active length lo
    multi[11] = 0x22; //FPDE horizontal Active length hi/FPHS period hi
    MWriteI2C(TW88, 0xa2, multi, 12);    
    WriteI2C(TW88, 0xaf, 0x21); //Dithering

    //0xb8-0xbe
    //Misc-input
    multi[0] = 0x14; //input routing
    multi[1] = 0x84; //buffer hold
    MWriteI2C(TW88, 0xb8, multi, 2);

//WriteI2C(I2C(TW88, 0xba, 0x02); 
 /*multi[0] = 0x00; 
    multi[1] = 0x00; 
    multi[2] = 0x00; 
    MWriteI2C(TW88, 0xbc, multi, 3);*/

    //0xf6-0xf7        
    //output interface
    multi[0] = 0x9e; //clock delay, en coast
    multi[1] = 0x01; //!Reverse the bit order on panel data bus
    MWriteI2C(TW88, 0xf6, multi, 2);

    //0xfa-0xfe
    //pll
    multi[0] = 0x32; //pll control 
    multi[1] = 0x03; //pll control 2
    multi[2] = 0x90; //pll control 3
    multi[3] = 0x01; //pll control 4
    multi[4] = 0x36; //pll control 5
    //0xff
    multi[5] = 0xff;
    MWriteI2C(TW88, 0xfa, multi, 6);
}

/**************************************************/
/*        NTSC_VGA_SHARP                          */
/*function : initialize TW88 register for         */
/*          NTSC input and SHARP VGA panel        */    
/*input : none                                    */
/*output : none                                   */ 
/**************************************************/
void NTSC_VGA_SHARP(void)
{
    //address 0x07-0x0d 
    //CROP_HI, VD