Suche LCD Treiber SSD1289

[Werner (Gast)]

Habe hier ein Display mit dem SSD1289 auch das Datenblatt aber noch 0 
Plan wie ich da ran gehen soll.

Kleine Tipps wären eventuell hilfreich. Hätte da ein User etwas für 
mich?

[ich (Gast)]

Es wäre hilfreich, wenn du uns verrätst, was du damit vorhast und was 
genau dein Problem ist?

[Werner (Gast)]

Nun ich möchte das Display ansteuern mit einem µc. Habe aber wie getippt 
noch kein Plan.

Zum einen nicht wie ich es Hardwaretechnisch anbinde.
Zum anderen wie ich ran gehe Softwaretechnisch etwas darzustellen.

Klar benötigt Ihr mit sicherheit noch einige Dinge. Nur was???

Sagt es mir und ich zeige euch auf was ich davon habe.

Also vorhanden Display mit SDD1289 treiber
Datenblatt
und STK500

[ich (Gast)]

Ganz ohne Plan wird das sicher nichts und selbst mit Plan ist das eine 
größere Aktion.
Im Datenblatt Kap. 15 INTERFACE MAPPING sind die Möglichkeiten für das 
Hardware-Interface zu deinem Controller beschrieben (Überblick in 
Tabelle 15-1)

[Werner (Gast)]

So habe mich nochmal durch das Datenblatt gelesen und gerade auch Kap. 
15

Werde aber nich so richtig schlau daraus.

Ich habe an meinem Display

3.3V
GND
D0-D15
CS
RS
WR
RD
BL_CNT
Reset

Diese kann ich im Datenblatt aber nicht finden

[Werner (Gast)]

Kennt sich keiner aus?

[Fabrice (Gast)]

Hallo ,

erst sorry for meine Deutch ;)
Ich haben eine SSD1289 Treiber geschriben in CCS C für microchip CPU.
Muss einfach sein für andere CPU zu konvertieren.
Hier ist das source code.

ssd1289.c // das haubt treiber.

/*
*************************************************************************************************
*     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
                  }
               }
            }
         }
      }
   }
}

jetzt die 5x7 punkt buschtaben.

FONT57.c

//                                                                            //
////////////////////////////////////////////////////////////////////////////////
//                     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
                         0x48, 0x54, 0x54, 0x54, 0x20, // s
                         0x04, 0x04, 0x3F, 0x44, 0x44, // t
                         0x3C, 0x40, 0x40, 0x20, 0x7C, // u
                         0x1C, 0x20, 0x40, 0x20, 0x1C, // v
                         0x3C, 0x40, 0x30, 0x40, 0x3C, // w
                         0x44, 0x28, 0x10, 0x28, 0x44, // x
                         0x0C, 0x50, 0x50, 0x50, 0x3C, // y
                         0x44, 0x64, 0x54, 0x4C, 0x44, // z
                         0x00, 0x08, 0x36, 0x41, 0x41, // {
                         0x00, 0x00, 0x7F, 0x00, 0x00, // |
                         0x41, 0x41, 0x36, 0x08, 0x00, // }
                         0x02, 0x01, 0x02, 0x04, 0x02};// ~

Zu benutzen ist nicht kompliziert.

IMMER herst LCD_Init(); das der tft initializiert.
Dann ist alles bereit für alle anderen funktion.

Ich hoffen das dir gehilfen haben.

Schuss ;)

Fabrice.
(Frankreich)

[Patrick h. (patabr)]

Hallo,
sorry für mein Deutsch Ich bin Französisch (translate mit google)

Ich kaufte mir dieses Moduls
http://www.ebay.com/itm/3-2-TFT-LCD-Module-Display-Touch-Panel-PCB-adapter-/190451748066#ht_5065wt_908

mit SSD1289 driver

Ich versuchte das prog F.Muller (sehr gut) für 2 Tage, aber nichts 
funktioniert .... Ich habe einen Zweifel über den Betrieb des Moduls,

könnten Sie mir ein sehr einfaches kleines prog (ich bin ein Anfänger) 
mit. für einen .hex ​​(for Pic16F877 or pic16F887 or PIC18f4525) und die 
Verkabelung zu sehen, ob es funktioniert

bitte
danke

[Fabrice (Gast)]

Hallo ,

Hier eine beispiel ich haben für diese treiber geschrieben.
Ist mit CCS C Compiler.

Tschuss :)

[Fabrice (Gast)]

Ich habe noch diese andere beispiel :)

Fabrice.

[Oliver (Gast)]

Diese Library unterstützt ebenfalls den SSD1289:
http://henningkarlsen.com/electronics/library.php?id=51

(Arduino und ChipKit Umgebung)

Oliver

[Michael N. (betonmicha)]

Hallo,

da ich auch keinen passenden Treiber gefunden habe der meinen 
Anforderungen entspricht, habe ich selber einen geschrieben.

Allerdings ist er noch nicht ganz fertig, was schon funktioniert ist:
- ungefülltes Rechteck zeichen.
- einzelne Pixel setzen
- und Text schreiben
- theoretisch auch Bildausgabe ( aber noch unvollständig)

Bei der Textausgabe bin ich schon fast fertig und es ist möglich mit 
einem Font Editor beliebige Schriftarten in theoretisch beliebiger Größe 
darzustellen. Hängt vom internen Speicher des AVR ab und ob die 
Schriftart auf dem Rechner installiert ist.
Muss da noch ein bisschen anpassen zwecks Höhe der Schrift und ein paar 
optimierungen machen.

Ich werde demnächst einen kleinen Artikel schreiben und dann auch den 
Quelltext veröffentlichen.

Läuft übrigens bei mir auf einem ATmega32 mit 20 MHz.

Gruß Michael

[Michael N. (betonmicha)]

Ich habe hier mal meinen Treiber für das SSD1289 hochgladen. Ist nur 
experimentell und ich kann im Moment auch nicht dran weiterarbeiten.

http://www.kulturschweine.de/2013/02/atmega32-und-ssd1289-display/

Gruß
Micha

[Mario X. (grinderfx)]

@Michael der Treiber ist ja ganz nett aber es wäre nett wenn noch 
irgendwo stehen würde welcher Pin wo hin muss.

Im Beitrag von Fabrice wird das ja auch gemacht
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