ksr810.c

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

      SerialDelay();
      SDA = 0;
	SerialDelay();
	SCL = 0;
}

/**************************************************/
/*        SerialStop                              */
/*function : Write serial stop condition          */
/*input : none                                    */
/*output : none                                   */ 
/**************************************************/
void SerialStop(void)
{
    SDA = 0;
    SerialDelay();
    SCL = 1;
    SerialDelay();
    SDA = 1;
}

/**************************************************/
/*        ReadData                                */
/*function : Read data from the serial port       */
/*input : none                                    */
/*output : unsigned char                          */ 
/**************************************************/
unsigned char ReadData(void)
{
    unsigned char i;
    unsigned char data = 0;

    CFSDA = 1; //slave controls SDA 

    for(i=0;i<8;i++)
    {
        SCL = 1;
        data <<= 1;
        if(SDA)
            data |= 1;
        SCL = 0;
    }
    CFSDA = 0; //PIC16F73 controls SDA
    SDA = 1; //send an no-acknowledge
    SerialDelay();
    SCL = 1;
    SerialDelay();
    SCL = 0;
    
    return(data);
}

/**************************************************/
/*        WriteData                               */
/*function : Write data to the serial port        */
/*input : unsigned char data                      */
/*output : unsigned char (0:error, 1:OK)          */ 
/**************************************************/
unsigned char WriteData(unsigned char data)
{
    int i;
    unsigned char ack = 0;

    for(i=0;i<8;i++)
    {
        if(!(data & 0x80))
            SDA = 0;
        else
            SDA = 1;
        SerialDelay();
        SCL = 1;
        data <<= 1;
        SerialDelay();
        SCL = 0;
    }
    SDA = 1;
    CFSDA = 1; //slave controls SDA
    SerialDelay();
    SCL = 1;
    SerialDelay();
    ack = SDA;
    SCL = 0;
    CFSDA = 0; //PIC16F73 controls SDA
   
    return(1-ack);
}

////////////////////////////////////////////////////
//            I2C functions                       //
////////////////////////////////////////////////////

/**************************************************/
/*        ReadI2C                                 */
/*function : Read data from the Serial bus        */
/*input :unsigned char address,unsigned char index*/
/*       unsigned char *data                      */
/*output : unsigned char (0:OK)                   */ 
/**************************************************/
unsigned char ReadI2C(unsigned char address, unsigned char index,
                       unsigned char *data)
{
    SerialStart();
    if(!WriteData(address)) 
    {
        SerialStop();
        return(1);
    } 
    if(!WriteData(index))
    {
        SerialStop();
        return(2);
    }  
    SerialStart();
    if(!WriteData(address+1)) 
    {
        SerialStop();
        return(3);
    } 
    (*data) = ReadData();
    SerialStop();
    return (0);
}

/**************************************************/
/*        WriteI2C                                */
/*function : Write data to the serial bus         */
/*input :unsigned char address,unsigned char index*/ 
/*       unsigned char data                       */
/*output : unsigned char (0:OK)                   */ 
/**************************************************/
unsigned char WriteI2C(unsigned char address, unsigned char index,
                       unsigned char data)
{
    SerialStart();
    if(!WriteData(address)) 
    {
        SerialStop();
        return(1);
    } 
    if(!WriteData(index))
    {
        SerialStop();
        return(2);
    }  
    if(!WriteData(data))
    {
        SerialStop();
        return(3);
    } 
    SerialStop();
    return(0);
}


////////////////////////////////////////////////////

/**************************************************/
/*        MReadI2C                                */
/*function : Multiple Read to the serial bus      */
/*           in ascending sequential order        */
/*input :unsigned char address,unsigned char index*/
/*       unsigned char *data,  unsigned char size */
/*output : unsigned char                          */ 
/**************************************************/
/*unsigned char MReadI2C(unsigned char address, unsigned char index,
         unsigned char *data, unsigned char size)
{
	unsigned char i;
    
    SerialStart();
	if(!WriteData(address))
    {
        SerialStop();
        return(0);
    } 
	if(!WriteData(index))
    {
        SerialStop();
        return(0);
    }  
	SerialStart(); 
	if(!WriteData(address+1))
    {
        SerialStop();
        return(0);
    } 
    
    for(i=0;i<size;i++)
	    (*(data+i)) = ReadData();
	
    SerialStop();
    return (1);

}
*/
/**************************************************/
/*        MWriteI2C                               */
/*function : Multiple Writes to the serial bus    */
/*           in ascending sequential order        */
/*input :unsigned char address,unsigned char index*/
/*       unsigned char *data,  unsigned char size */
/*output : unsigned char                          */ 
/**************************************************/
unsigned char MWriteI2C(unsigned char address, unsigned char index,
        unsigned char *data, unsigned char size)
{
    unsigned char i;

    SerialStart();
	if(!WriteData(address))
    {
        SerialStop();
        return(0);
    }  
    if(!WriteData(index))
    {
        SerialStop();
        return(0);
    } 
    for(i=0;i<size;i++)
    {
	    if(!WriteData((*(data+i))))
        {
            SerialStop();
            return(0);
        }
    } 
	SerialStop();
    return(1);

}

////////////////////////////////////////////////////
//            Display functions                   //
////////////////////////////////////////////////////

/**************************************************/
/*        InitWindow1                             */
/*function : initialize window1 registers         */
/*input : none                                    */
/*output : none                                   */ 
/**************************************************/
void InitWindow1(void)
{
    unsigned char window_val[NB_WINOPTION];

  //use Multi-write function
    InitTable(window_val, NB_WINOPTION); 
    window_val[0]  = WIN1;
    window_val[1]  = HSTART1;
    window_val[2]  = VSTART1;
    window_val[3]  = WINW1;
    window_val[4]  = WINH1;
    window_val[5]  = BOR1;
    window_val[6]  = BORH1;
    window_val[7]  = BORV1;
    window_val[8]  = HSPACE1;
    window_val[9]  = VSPACE1;
    window_val[10] = ADDSTART1;
    MWriteI2C(TW88, WINDOW1, window_val, NB_WINOPTION);
/*
    WriteI2C(TW88, WINDOW1, WIN1);
    WriteI2C(TW88, W1_HSTART, HSTART1);
    WriteI2C(TW88, W1_VSTART, VSTART1);
    WriteI2C(TW88, W1_WIDTH, WINW1);
    WriteI2C(TW88, W1_HEIGHT, WINH1);
    WriteI2C(TW88, BORDER1, BOR1);
    WriteI2C(TW88, B1_H , BORH1);
    WriteI2C(TW88, B1_V, BORV1);
    WriteI2C(TW88, W1_HSPACE, HSPACE1);
    WriteI2C(TW88, W1_VSPACE, VSPACE1);
    WriteI2C(TW88, W1_ADDSTART, ADDSTART1);
 */       
}

/**************************************************/
/*        DisplayW1                               */
/*function : Display window1                      */
/*           display : "text"(2space)"value"      */ 
/*input :  const char *text                       */
/*output : none                                   */ 
/**************************************************/
void DisplayW1(const char *text)
{
    unsigned char tab[BAR_MAX];   
    unsigned char level=0;
    
    cnt = 0;
    addstart = ADDSTART1;
    win_size = SIZE1;
    font_op = FONT1; 

        level = ConvVal();
        SetValBar(tab,level); 
     
        INTE=0;
        //display text on window1
        putst(text); 
    
        font_op = 0x82; 
        putst(tab);

        font_op = FONT1; 
        Conv10(level, tab); //convert value into ASCII code 
                        //in the number10 table
        putst(" ");
        putst(tab);
    
        INTE=1;  
    WriteI2C(TW88, W1_WIDTH, cnt); //set Window1 width 
    WriteI2C(TW88, WINDOW1, WIN1 | 0x01); //enable window1     
      
}

/**************************************************/
/*        InitWindow2                             */
/*function : initialize window2 registers         */
/*input : none                                    */
/*output : none                                   */ 
/**************************************************/
void InitWindow2(void)
{
   unsigned char window_val[NB_WINOPTION];
   
  //use Multi-write function
   InitTable(window_val, NB_WINOPTION); 
    window_val[0]  = WIN2;
    window_val[1]  = HSTART2;
    window_val[2]  = VSTART2;
    window_val[3]  = WINW2;
    window_val[4]  = WINH2;
    window_val[5]  = BOR2;
    window_val[6]  = BORH2;
    window_val[7]  = BORV2;
    window_val[8]  = HSPACE2;
    window_val[9]  = VSPACE2;
    window_val[10] = ADDSTART2;
    MWriteI2C(TW88, WINDOW2, window_val, NB_WINOPTION);
   
/*
    WriteI2C(TW88, WINDOW2, WIN2);
    WriteI2C(TW88, W2_HSTART, HSTART2);
    WriteI2C(TW88, W2_VSTART, VSTART2);
    WriteI2C(TW88, W2_WIDTH, WINW2);
    WriteI2C(TW88, W2_HEIGHT, WINH2);
    WriteI2C(TW88, BORDER2, BOR2);
    WriteI2C(TW88, B2_H , BORH2);
    WriteI2C(TW88, B2_V, BORV2);
    WriteI2C(TW88, W2_HSPACE, HSPACE2);
    WriteI2C(TW88, W2_VSPACE, VSPACE2);
    WriteI2C(TW88, W2_ADDSTART, ADDSTART2);
*/ 
}

/**************************************************/
/*        DisplayW2                               */
/*function : Display window2                      */
/*input :  const char *text                       */
/*output : none                                   */ 
/**************************************************/
void DisplayW2(const char *text)
{
    cnt = 0;
    addstart = ADDSTART2;
    win_size = SIZE2;
    font_op = FONT2;

    INTE=0;           
    
    //write text to display on window2
    putst(text);
    INTE=1;
    WriteI2C(TW88, W2_WIDTH, cnt); //set Window1 width 
    WriteI2C(TW88, WINDOW2, WIN2 | 0x01); //enable window2      
}

/**************************************************/
/*        InitWindow3                             */
/*function : initialize window3 registers         */
/*input : none                                    */
/*output : none                                   */ 
/**************************************************/
void InitWindow3(void)
{
   unsigned char window_val[NB_WINOPTION];
   
   //use Multi-write function
   InitTable(window_val, NB_WINOPTION); 
    window_val[0]  = WIN3;
    window_val[1]  = HSTART3;
    window_val[2]  = VSTART3;
    window_val[3]  = WINW3;
    window_val[4]  = WINH3;
    window_val[5]  = BOR3;
    window_val[6]  = BORH3;
    window_val[7]  = BORV3;
    MWriteI2C(TW88, WINDOW3, window_val, 9);
    WriteI2C(TW88, W3_VSPACE, VSPACE3);
    WriteI2C(TW88, W3_ADDSTART, ADDSTART3); 
     
/*
    WriteI2C(TW88, WINDOW3, WIN3);
    WriteI2C(TW88, W3_HSTART, HSTART3);
    WriteI2C(TW88, W3_VSTART, VSTART3);
    WriteI2C(TW88, W3_WIDTH, WINW3);
    WriteI2C(TW88, W3_HEIGHT, WINH3);
    WriteI2C(TW88, BORDER3, BOR3);
    WriteI2C(TW88, B3_H , BORH3);
    WriteI2C(TW88, B3_V, BORV3);
    
    WriteI2C(TW88, W3_VSPACE, VSPACE3);
    WriteI2C(TW88, W3_ADDSTART, ADDSTART3);
*/ 
}

/**************************************************/
/*        DisplayW3                               */
/*function : Display window3                      */
/*input :  const char *text                       */
/*output : none                                   */ 
/**************************************************/
void DisplayW3(void)
{
    
    cnt = 0;
    addstart = ADDSTART3;
    win_size = SIZE3;
    font_op = FONT3 & 0xF7; //blink off

    //display battery on window3
    INTE=0;           
    WriteI2C(TW88, FONT_SELECT, ROM | 0x01); //Select font from rom
                                        //Enable OSD RAM access        
    putch(addstart+cnt, 0xb6);                   
    cnt++;
    putch(addstart+cnt, 0xb8);                   
    cnt++;
    WriteI2C(TW88, FONT_SELECT, ROM); //disable OSD RAM access 

    INTE=1;
    WriteI2C(TW88, W3_WIDTH, cnt); //set Window1 width 
    WriteI2C(TW88, WINDOW3, WIN3 | 0x01); //enable window4      
}

/**************************************************/