Suche LCD Treiber SSD1289

/*

*************************************************************************************************

*     TFT LCD 262k Couleur , Controlleur Solomon system's SSD1289

*                              Tout droits réservé

* On va utiliser 65k couleur (16bits pour la rapidité)

* Nom fichier    : SSD1289.c

* Programmeur    : Muller F. , conversion en CCS C , ajout des fonctions graphiques.

*                              reprise et convertion de LCD_Init de Techtoys

* Note           : v2.1 (LCD_Rect modifié , INT8U et INT16U remplacé)

* Matériel       : PIC18F4685 , 32Mhz (Int_Osc 8Mhz , PLL X4)

* Date           : 08 Mai 2011

*************************************************************************************************

*                              DESCRIPTION

*

* Ce module est une interface pour l'ecran TFT 262k Couleur de 240 x 320 points

* Controllé par SSD1289

* L'ecran est alimenté en 3.3V, La LED d'eclairage de l'ecran consome 15mA

* La LED d'eclairage est alimenté par le CAT32 pour 15mA constant (FG020214_BO)

* <PS3:PS1:PS0> configuré en  <1:0:0> pour un bus de données de 8 bits en mode 8080

*

* Fonctions des broches du LCD sur la carte FG020214_BO (www.TechToys.com.hk)

* ---------   LCD              PIC -----------------

* pin 2      SHDN_BL  - Non utilisé ici, connecter à VCC avec une resistance de 100k

* pin 4       GND     - GND

* pin 6       VCC     - Alim 3.3V

* pin 10      WR      - RC0

* pin 12      RD      - RC1

* pin 14      CS      - RC2

* pin 16      CD      - RC6

* pin 18      RST     - Vers reset du CPU (MCLR du PIC)

* pin 20:34   D1:D8   - Port de données de l'ecran connecté à RD0:RD7

*

* Remarques : Les broches de nombre impair ne sont pas connectées en mode de données 8 bits

*

***********************************************************************************************

*/

/*

*************************************************************************************************

*                                 Definitions Locale

*************************************************************************************************

*/

#include <FONT57.c>

//#include <image.c>

/*

*************************************************************************************************

*        Definition du Délais entre les pulses Haut et Bas sur les broches de l'écran

*        A 40Mhz 1 cycle = 100ns (10Mips) (Enlever les comments dans LCD_Cmd,LCD_Read et LCD_Data

*        Inutile à 32Mhz et inférieur

*************************************************************************************************

*/

#define  att1           1

/*

*************************************************************************************************

*                                 Taille de l'ecran

*************************************************************************************************

*/

#define  GCLCDX         239

#define  GCLCDY         319

#define  X_START        0

#define  Y_START        0

#define  X_END          GCLCDX + 1

#define  Y_END          GCLCDY + 1

/*

*************************************************************************************************

*                                 Les Commandes du SSD1289

*************************************************************************************************

*/

// Utilisé dans init

#define OSC_START            0x00

#define DRIVER_OUT           0x01

#define LCD_DRIVE_AC         0x02

#define POWER_CONTROL1       0x03

#define POWER_CONTROL2       0x0C

#define POWER_CONTROL3       0x0D

#define POWER_CONTROL4       0x0E

#define POWER_CONTROL5       0x1E

#define DISPLAY_CONTROL      0x07

#define ENTRY_MODE           0x11

#define SLEEP_MODE           0x10

#define HORIZONTAL_RAM_START 0x44

#define VERTICAL_RAM_START   0x45

#define VERTICAL_RAM_END     0x46

#define RAM_WRITE            0x22

// Commandes complémentaires

#define LCD_X                0x4E

#define LCD_Y                0x4F

/*

***********************************************************************************************

* RGB en 16 bits, pour mode 65k couleurs

* [R4R3R2R1R0G5G4G3][G2G1G0B4B3B2B1B0]

***********************************************************************************************

*/

#define RGB16(r,g,b)   ((unsigned int16)r<<11)+(unsigned int16)g<<5)+(unsigned int8)b

/*

***********************************************************************************************

*                        Definition de quelques couleurs de base en 16 bits

***********************************************************************************************

*/

#define  NONE        0x0001      // Juste pour preciser qu'il n'y à pas de couleur

#define BLEU         0x001F

#define JAUNE        0xFFE0

#define ROUGE        0xF800

#define VERT         0x07E0

#define NOIR         0x0000

#define BLANC        0xFFFF

#define VERTCLAIR    0xEFE0

#define VERTFONCE    0XE0E0

#define ROUGEFONCE   0XF200

#define BLEUFONCE    0X000F

#define BLEUCLAIR    0X07FF

#define ORANGE       0XF8E0

#define MAUVE        0XF81F

/*

***********************************************************************************************

*                        Definition des broches , CCS C

*                        Materiel : PIC18F4680

***********************************************************************************************

*/

#define  glcd_wr             PIN_C0

#define  glcd_rd             PIN_C1

#define  glcd_cs             PIN_C2

#define  glcd_cd             PIN_C6

// LCD Data port D1:D8 --> PIC Port D0:D7

/*

***********************************************************************************************

*                              Constantes Globale

***********************************************************************************************

*/

#define YES                1

#define NO                 0

#define HIGH               1

#define LOW                0

/*

***********************************************************************************************

*                           Definition des fonctions

***********************************************************************************************

*/

void LCD_Init(void);

void LCD_CLS(unsigned int16 couleur);

void LCD_Cmd(unsigned int8 cmd);

void LCD_Data(unsigned int8 dat);

unsigned int8 LCD_Read(void);

unsigned int16 LCD_Read_Pixel(unsigned int8 x , unsigned int16 y);

void LCD_Fillscreen(unsigned int8 x1, unsigned int16 y1, unsigned int8 x2, unsigned int16 y2,unsigned int16 couleur);

void LCD_Pixel(unsigned int8 x , unsigned int16 y , unsigned int16 couleur);

void LCD_Ligne(unsigned int8 x1 , unsigned int16 y1 ,unsigned int8 x2 , unsigned int16 y2 , unsigned int16 couleur);

void LCD_Rect(unsigned int8 x1, unsigned int16 y1, unsigned int8 x2, unsigned int16 y2, unsigned int8 plein, unsigned int16 couleur);

void LCD_Cercle(unsigned int8 x, unsigned int16 y, unsigned int16 rayon, unsigned int8 plein, unsigned int16 couleur);

void LCD_Text57(unsigned int8 x, unsigned int16 y, char* textptr, char Taille, unsigned int16 couleur, unsigned int16 couleur_arriere);

/*

*************************************************************************************************

*                                     DISPLAY INITIALIZATION

*

* Description : This function initializes the LCD module      

* Arguments   : none

*         

* Returns     : none

* Note        : This function should be called once before any of the other functions

*************************************************************************************************

*/

void LCD_Init(void)

{

   // Set the cmd port

   Set_Tris_C(0x00);   // Port_C all outputs

   // Set the data port

   Set_Tris_D(0x00);   // Port_D all outputs

   // Set all bit from Port C and D to 0

   Output_C(0x00);

   Output_D(0x00);

   // Start screen initialisation

   LCD_Cmd(OSC_START);          //Start Oscillation

   LCD_Data(0x00);

   LCD_Data(0x01);

   LCD_Cmd(DRIVER_OUT);         //Driver Output Control

   LCD_Data(0x23);

   LCD_Data(0x3F);

   LCD_Cmd(LCD_DRIVE_AC);       //LCD Drive AC Control

   LCD_Data(0x06);

   LCD_Data(0x00);

   LCD_Cmd(POWER_CONTROL1);     //Power Control (1)

   LCD_Data(0xA8);

   LCD_Data(0xA6);

   LCD_Cmd(DISPLAY_CONTROL);    //Display Control

   LCD_Data(0x00);

   LCD_Data(0x33);

   LCD_Cmd(ENTRY_MODE);         //Set Display color mode for 65k color

   LCD_Data(0x68);

   LCD_Data(0x30);

   LCD_Cmd(POWER_CONTROL2);     //Power Control (2)

   LCD_Data(0x00);

   LCD_Data(0x05);

   LCD_Cmd(POWER_CONTROL3);     //Power Control (3)

   LCD_Data(0x30);

   LCD_Data(0x0B);

   LCD_Cmd(POWER_CONTROL4);     //Power Control (4)

   LCD_Data(0x20);

   LCD_Data(0x00);

   LCD_Cmd(SLEEP_MODE);         //Exit Sleep Mode

   LCD_Data(0x00);

   LCD_Data(0x00);

   Delay_Ms(30);                //delay 30ms

   LCD_Cmd(POWER_CONTROL5);     //Power Control (5)

   LCD_Data(0x00);

   LCD_Data(0xA8);

   LCD_Cmd(HORIZONTAL_RAM_START);   //Horizontal RAM address position start/end setup

   LCD_Data(0xEF);                  //decimal 239

   LCD_Data(0x00);                  //decimal 0, i.e. horizontal ranges from 0 -> 239

                                    //POR value is 0xEF00 anyway. This address must be set before RAM write

   LCD_Cmd(VERTICAL_RAM_START);     //Vertical RAM address start position setting

   LCD_Data(0x00);                  //0x0000 = decimal 0

   LCD_Data(0x00);

   LCD_Cmd(VERTICAL_RAM_END);       //Vertical RAM address end position setting

   LCD_Data(0x01);                  //0x013F = decimal 319

   LCD_Data(0x3F);

   LCD_Cmd(RAM_WRITE);              //Commande d'ecriture dans la Memoire ecran

   LCD_CLS(BLANC);                  //initialize le LCD en couleur Blanche (mode 16 Bits)

}

/*

*************************************************************************************************

*                            Effacer tout l'ecran en mettant tout les pixels

*                             à la couleur passé en argument (mode 16Bits)

*

* Arguments   : 'couleur' format 16 bits RGB16(r,g,b)(mode 565)

*                                    [R4R3R2R1R0G5G4G3][G2G1G0B4B3B2B1B0]

*            Pour (r,g,b) de (0,0,0) à (31,63,31)

*************************************************************************************************

*/

void LCD_CLS(unsigned int16 couleur)

{

   unsigned int8 i,hiByte,lowByte;

   unsigned int16 j;

   hiByte  = couleur>>8;

   lowByte = (unsigned int8)couleur;

   LCD_Cmd(RAM_WRITE);

   for(j=0;j<Y_END;j++)

   {

      for(i=0;i<X_END;i++)

      {

         LCD_Data(hiByte);LCD_Data(lowByte);

      }

   }

}   

/*

*************************************************************************************************

*                                     Envoyer une commande à l'écran

*************************************************************************************************

*/

void LCD_Cmd(unsigned int8 cmd)

{

   Output_D(cmd);

   //delay_cycles(att1);

   output_bit(glcd_cd,LOW);       //CD LOW pour commande

   //delay_cycles(att1);

   output_bit(glcd_wr,LOW);

   //delay_cycles(att1);

   output_bit(glcd_rd,HIGH);

   //delay_cycles(att1);

   output_bit(glcd_cs,LOW);

   //delay_cycles(att1);

   output_bit(glcd_cs,HIGH);

   //delay_cycles(att1);

}

/*

*************************************************************************************************

*                                     Envoyer une donnée 8 bits à l'écran

*************************************************************************************************

*/

void LCD_Data(unsigned int8 dat)

{

   Output_D(dat);

   //delay_cycles(att1);

   output_bit(glcd_cd,HIGH);      //CD HIGH pour display data

   //delay_cycles(att1);

   output_bit(glcd_wr,LOW);

   //delay_cycles(att1);

   output_bit(glcd_rd,HIGH);

   //delay_cycles(att1);

   output_bit(glcd_cs,LOW);

   //delay_cycles(att1);

   output_bit(glcd_cs,HIGH);

   //delay_cycles(att1);

}

/*

*************************************************************************************************

*                                     Lire une donnée 8 bits de l'écran

*************************************************************************************************

*/

unsigned int8 LCD_Read(void)

{

   unsigned int8 Lecture = 0;

   output_bit(glcd_wr,HIGH);

   //delay_cycles(att1);

   output_bit(glcd_rd,LOW);

   //delay_cycles(att1);

   output_bit(glcd_cd,HIGH);      //CD HIGH pour display data

   //delay_cycles(att1);

   output_bit(glcd_cs,LOW);

   //delay_cycles(att1);

   Lecture = input_d();

   output_bit(glcd_cs,HIGH);

   //delay_cycles(att1);

   output_bit(glcd_rd,HIGH);

   //delay_cycles(att1);

   return Lecture;

}

/*

*************************************************************************************************

*                         Lecture de la couleur d'un point dans l'écran

*   x       : 0 à 239

*   y       : 0 à 319

*   couleur : format 16 bits RGB16(r,g,b)

*************************************************************************************************

*/

unsigned int16 LCD_Read_Pixel(unsigned int8 x , unsigned int16 y)

{

   unsigned int8 hiByte, lowByte;

   unsigned int16 Couleur;

   hiByte  = y>>8;

   lowByte = (unsigned int8)y;

   LCD_Cmd(LCD_X);                              // coordonnée X

   LCD_Data(0x00);                              // Coordonnée toujours en 16bits (bit de poid

                                                // fort en 1er (0x00 pour 'x' qui est en 8 bits

   LCD_Data(x);

   LCD_Cmd(LCD_Y);                              // coordonnée Y

   LCD_Data(hiByte);

   LCD_Data(lowByte);

   // Maintenant on lis les 2 Bytes de la couleur et

   //on converti en 16 Bits

   LCD_Cmd(RAM_WRITE);

   hibyte = LCD_Read();                         //Lecture pour rien (retourne le numero de la cmd)

   hibyte = LCD_Read();

   lowbyte = LCD_Read();

   Couleur = Make16(hibyte,lowbyte);

   return Couleur;

}

/*

*************************************************************************************************

*                                     Afficher un point dans l'écran

*   x       : 0 à 239

*   y       : 0 à 319

*   couleur : format 16 bits RGB16(r,g,b)

*************************************************************************************************

*/

void LCD_Pixel(unsigned int8 x , unsigned int16 y , unsigned int16 couleur)

{

   unsigned int8 hiByte, lowByte;

   // Verifier si le pixel est dans l'ecran (juste verifier bord droit et bas)

   if ((x>GCLCDX) || (y>GCLCDY))

      continue;

   else

   {

      hiByte  = y>>8;

      lowByte = (unsigned int8)y;

      LCD_Cmd(LCD_X);                              // coordonnée X

      LCD_Data(0x00);                              // Coordonnée toujours en 16bits (bit de poid

                                                   // fort en 1er (0x00 pour 'x' qui est en 8 bits

      LCD_Data(x);

      LCD_Cmd(LCD_Y);                              // coordonnée Y

      LCD_Data(hiByte);

      LCD_Data(lowByte);

      hiByte  = couleur>>8;

      lowByte = (unsigned int8)couleur;

      LCD_Cmd(RAM_WRITE);

      LCD_Data(hiByte);LCD_Data(lowByte);

   }

}

/*

*************************************************************************************************

*                                     Tracer une ligne dans l'écran

*   x1      : 0 à 239   : debut x

*   y1      : 0 à 319   : debut y

*   x2      : 0 à 239   : fin x

*   y2      : 0 à 319   : fin y

*   couleur : format 16 bits RGB16(r,g,b)

*************************************************************************************************

*/

void LCD_Ligne(unsigned int8 x1 , unsigned int16 y1 ,unsigned int8 x2 , unsigned int16 y2 , unsigned int16 couleur)

{

   int16        dy, dx;

   signed int8  addx=1, addy=1;

   signed int16 P, diff;

   int16 i=0;

   dx = abs((signed int8)(x2 - x1));

   dy = abs((signed int16)(y2 - y1));

   if(x1 > x2)

      addx = -1;

   if(y1 > y2)

      addy = -1;

   if(dx >= dy)

   {

      dy *= 2;

      P = dy - dx;

      diff = P - dx;

      for(; i<=dx; ++i)

      {

         LCD_Pixel(x1, y1, couleur);

         if(P < 0)

         {

            P  += dy;

            x1 += addx;

         }

         else

         {

            P  += diff;

            x1 += addx;

            y1 += addy;

         }

      }

   }

   else

   {

      dx *= 2;

      P = dx - dy;

      diff = P - dy;

      for(; i<=dy; ++i)

      {

         LCD_Pixel(x1, y1, couleur);

         if(P < 0)

         {

            P  += dx;

            y1 += addy;

         }

         else

         {

            P  += diff;

            x1 += addx;

            y1 += addy;

         }

      }

   }

}

/*

*************************************************************************************************

*                                     Rempli une partie de l'écran

*   x1      : 0 à 239   : debut x

*   y1      : 0 à 319   : debut y

*   x2      : 0 à 239   : fin x

*   y2      : 0 à 319   : fin y

*   couleur : format 16 bits RGB16(r,g,b)

*************************************************************************************************

*/

void LCD_Fillscreen(unsigned int8 x1, unsigned int16 y1, unsigned int8 x2, unsigned int16 y2,unsigned int16 couleur)

{

   int16 i;

   for(i=y1; i<y2; i++)

   {

      LCD_Ligne(x1 , i , x2 , i , couleur);

   }

}

/*

*************************************************************************************************

*                                     Tracer un Rectangle dans l'écran

*   x1      : 0 à 239   : debut x

*   y1      : 0 à 319   : debut y

*   x2      : 0 à 239   : fin x

*   y2      : 0 à 319   : fin y

*   plein   : YES ou NO (rectangle plein ou vide)

*   couleur : format 16 bits RGB16(r,g,b)

*************************************************************************************************

*/

void LCD_Rect(unsigned int8 x1, unsigned int16 y1, unsigned int8 x2, unsigned int16 y2, unsigned int8 plein, unsigned int16 couleur)

{

   unsigned int8 i,TempX;

   unsigned int16 j,TempY;

   // Tester si x1 et y1 sont inferieures a x2 et y2

   if (x1 > x2)

      {

         TempX = x2;

         x2 = x1;

         x1 = TempX;

      }

   if (y1 > y2)

      {

         TempY = y2;

         y2 = y1;

         y1 = TempY;

      }

   if(plein)

      for(i=x1; i<x2; i++)

         for(j=y1; j<y2; j++)

            LCD_Pixel(i , j , couleur);

   else

      {

         LCD_Ligne(x1, y1, x2, y1, couleur);

         LCD_Ligne(x1, y2, x2, y2, couleur);

         LCD_Ligne(x1, y1, x1, y2, couleur);

         LCD_Ligne(x2, y1, x2, y2, couleur);

      }

}

/*

*************************************************************************************************

*                                     Tracer un Cercle dans l'écran

*   x1      : 0 à 239   : debut x

*   y1      : 0 à 319   : debut y

*   rayon   : Rayon du cercle

*   plein   : YES ou NO (cercle plein ou vide)

*   couleur : format 16 bits RGB16(r,g,b)

*************************************************************************************************

*/

void LCD_Cercle(unsigned int8 x, unsigned int16 y, unsigned int16 rayon, unsigned int8 plein, unsigned int16 couleur)

{

   signed int16 a, b, P;

   a = 0;

   b = rayon;

   P = 1 - rayon;

   do

   {

      if(plein)

      {

         LCD_Ligne(x-a, y+b, x+a, y+b, couleur);

         LCD_Ligne(x-a, y-b, x+a, y-b, couleur);

         LCD_Ligne(x-b, y+a, x+b, y+a, couleur);

         LCD_Ligne(x-b, y-a, x+b, y-a, couleur);

      }

      else

      {

         LCD_Pixel(a+x, b+y, couleur);

         LCD_Pixel(b+x, a+y, couleur);

         LCD_Pixel(x-a, b+y, couleur);

         LCD_Pixel(x-b, a+y, couleur);

         LCD_Pixel(b+x, y-a, couleur);

         LCD_Pixel(a+x, y-b, couleur);

         LCD_Pixel(x-a, y-b, couleur);

         LCD_Pixel(x-b, y-a, couleur);

      }

      if(P < 0)

         P+= 3 + 2*a++;

      else

         P+= 5 + 2*(a++ - b--);

    } while(a <= b);

}

/*

*************************************************************************************************

*                                     Tracer un texte avec la Fonte 5 x 7 points

*   x1      : 0 à 239

*   y1      : 0 à 319

*   Taille  : Utiliser 1 pour la taille normale , ou >1 pour agrandir les caracteres

*   couleur         : format 16 bits RGB16(r,g,b)    ** Couleur des caractere

*   couleur_arriere : format 16 bits RGB16(r,g,b)    ** Couleur d'arriere plan des caracteres

*************************************************************************************************

*/

void LCD_Text57(unsigned int8 x, unsigned int16 y, char* textptr, char Taille, unsigned int16 couleur, unsigned int16 couleur_arriere)

{

   int8 j, k, l, m;                                        // Compteurs

   int8 pixelData[5];                                      // enregistre les données du caractere

   for(; *textptr != '\0'; ++textptr, ++x)                 // Compter jusqu'a la fin du texte

   {

      if(*textptr < 'S') // Regarde si le caractere est stocké dans le 1er tableau de chaine

         memcpy(pixelData, FONT[*textptr - ' '], 5);

      else if(*textptr <= '~') // Regarde si le caractere est stocké dans le 2eme tableau de chaine

         memcpy(pixelData, FONT2[*textptr - 'S'], 5);

      else

         memcpy(pixelData, FONT[0], 5);   // Si caractere non trouvé alors considerer comme espace

       // Retour a la ligne et nouvelle ligne

      switch(*textptr)

      {

         case '\n':

            y += 7*Taille + 1;

            continue;

         case '\r':

            x = 0;

            continue;

      }

      if(x+5*Taille > X_END)                                        // Performs character wrapping

      {

         x = 0;                                                     // Set x at far left position

         y += 7*Taille + 1;                                         // Set y at next position down

      }

      for(j=0; j<5; ++j, x+=Taille)                                 // Loop through character byte data

      {

         for(k=0; k < 7; ++k)                                       // Loop through the vertical pixels

         {

            if(bit_test(pixelData[j], k))                           // Check if the pixel should be set

            {

               for(l=0; l < Taille; ++l)                            // These two loops change the

               {

                  for(m=0; m < Taille; ++m)

                  {

                     LCD_Pixel(x+m, y+k*Taille+l, couleur);         // Draws the pixel

                  }

               }

            }

            else if (couleur_arriere != NONE)

            {

               for(l=0; l < Taille; ++l)                            // These two loops change the

               {                                                    // Pixel back color

                  for(m=0; m < Taille; ++m)

                  {

                     LCD_Pixel(x+m, y+k*Taille+l, couleur_arriere); // Draws the pixel

                  }

               }

            }

         }

      }

   }

}

//                                                                            //

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

//                     fonte 5x7                                              //

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

//                                                                            //

const int8 FONT[51][5] ={0x00, 0x00, 0x00, 0x00, 0x00, // SPACE

                         0x00, 0x00, 0x5F, 0x00, 0x00, // !

                         0x00, 0x03, 0x00, 0x03, 0x00, // "

                         0x14, 0x3E, 0x14, 0x3E, 0x14, // #

                         0x24, 0x2A, 0x7F, 0x2A, 0x12, // $

                         0x43, 0x33, 0x08, 0x66, 0x61, // %

                         0x36, 0x49, 0x55, 0x22, 0x50, // &

                         0x00, 0x05, 0x03, 0x00, 0x00, // '

                         0x00, 0x1C, 0x22, 0x41, 0x00, // (

                         0x00, 0x41, 0x22, 0x1C, 0x00, // )

                         0x14, 0x08, 0x3E, 0x08, 0x14, // *

                         0x08, 0x08, 0x3E, 0x08, 0x08, // +

                         0x00, 0x50, 0x30, 0x00, 0x00, // ,

                         0x08, 0x08, 0x08, 0x08, 0x08, // -

                         0x00, 0x60, 0x60, 0x00, 0x00, // .

                         0x20, 0x10, 0x08, 0x04, 0x02, // /

                         0x3E, 0x51, 0x49, 0x45, 0x3E, // 0

                         0x00, 0x04, 0x02, 0x7F, 0x00, // 1

                         0x42, 0x61, 0x51, 0x49, 0x46, // 2

                         0x22, 0x41, 0x49, 0x49, 0x36, // 3

                         0x18, 0x14, 0x12, 0x7F, 0x10, // 4

                         0x27, 0x45, 0x45, 0x45, 0x39, // 5

                         0x3E, 0x49, 0x49, 0x49, 0x32, // 6

                         0x01, 0x01, 0x71, 0x09, 0x07, // 7

                         0x36, 0x49, 0x49, 0x49, 0x36, // 8

                         0x26, 0x49, 0x49, 0x49, 0x3E, // 9

                         0x00, 0x36, 0x36, 0x00, 0x00, // :

                         0x00, 0x56, 0x36, 0x00, 0x00, // ;

                         0x08, 0x14, 0x22, 0x41, 0x00, // <

                         0x14, 0x14, 0x14, 0x14, 0x14, // =

                         0x00, 0x41, 0x22, 0x14, 0x08, // >

                         0x02, 0x01, 0x51, 0x09, 0x06, // ?

                         0x3E, 0x41, 0x59, 0x55, 0x5E, // @

                         0x7E, 0x09, 0x09, 0x09, 0x7E, // A

                         0x7F, 0x49, 0x49, 0x49, 0x36, // B

                         0x3E, 0x41, 0x41, 0x41, 0x22, // C

                         0x7F, 0x41, 0x41, 0x41, 0x3E, // D

                         0x7F, 0x49, 0x49, 0x49, 0x41, // E

                         0x7F, 0x09, 0x09, 0x09, 0x01, // F

                         0x3E, 0x41, 0x41, 0x49, 0x3A, // G

                         0x7F, 0x08, 0x08, 0x08, 0x7F, // H

                         0x00, 0x41, 0x7F, 0x41, 0x00, // I

                         0x30, 0x40, 0x40, 0x40, 0x3F, // J

                         0x7F, 0x08, 0x14, 0x22, 0x41, // K

                         0x7F, 0x40, 0x40, 0x40, 0x40, // L

                         0x7F, 0x02, 0x0C, 0x02, 0x7F, // M

                         0x7F, 0x02, 0x04, 0x08, 0x7F, // N

                         0x3E, 0x41, 0x41, 0x41, 0x3E, // O

                         0x7F, 0x09, 0x09, 0x09, 0x06, // P

                         0x1E, 0x21, 0x21, 0x21, 0x5E, // Q

                         0x7F, 0x09, 0x09, 0x09, 0x76};// R

const int8 FONT2[44][5]={0x26, 0x49, 0x49, 0x49, 0x32, // S

                         0x01, 0x01, 0x7F, 0x01, 0x01, // T

                         0x3F, 0x40, 0x40, 0x40, 0x3F, // U

                         0x1F, 0x20, 0x40, 0x20, 0x1F, // V

                         0x7F, 0x20, 0x10, 0x20, 0x7F, // W

                         0x41, 0x22, 0x1C, 0x22, 0x41, // X

                         0x07, 0x08, 0x70, 0x08, 0x07, // Y

                         0x61, 0x51, 0x49, 0x45, 0x43, // Z

                         0x00, 0x7F, 0x41, 0x00, 0x00, // [

                         0x02, 0x04, 0x08, 0x10, 0x20, // \

                         0x00, 0x00, 0x41, 0x7F, 0x00, // ]

                         0x04, 0x02, 0x01, 0x02, 0x04, // ^

                         0x40, 0x40, 0x40, 0x40, 0x40, // _

                         0x00, 0x01, 0x02, 0x04, 0x00, // `

                         0x20, 0x54, 0x54, 0x54, 0x78, // a

                         0x7F, 0x44, 0x44, 0x44, 0x38, // b

                         0x38, 0x44, 0x44, 0x44, 0x44, // c

                         0x38, 0x44, 0x44, 0x44, 0x7F, // d

                         0x38, 0x54, 0x54, 0x54, 0x18, // e

                         0x04, 0x04, 0x7E, 0x05, 0x05, // f

                         0x08, 0x54, 0x54, 0x54, 0x3C, // g

                         0x7F, 0x08, 0x04, 0x04, 0x78, // h

                         0x00, 0x44, 0x7D, 0x40, 0x00, // i

                         0x20, 0x40, 0x44, 0x3D, 0x00, // j

                         0x7F, 0x10, 0x28, 0x44, 0x00, // k

                         0x00, 0x41, 0x7F, 0x40, 0x00, // l

                         0x7C, 0x04, 0x78, 0x04, 0x78, // m

                         0x7C, 0x08, 0x04, 0x04, 0x78, // n

                         0x38, 0x44, 0x44, 0x44, 0x38, // o

                         0x7C, 0x14, 0x14, 0x14, 0x08, // p

                         0x08, 0x14, 0x14, 0x14, 0x7C, // q

                         0x00, 0x7C, 0x08, 0x04, 0x04, // r