Important announcement: there is an English version of this forum on
Datum:
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?
Datum:
Es wäre hilfreich, wenn du uns verrätst, was du damit vorhast und was genau dein Problem ist?
Datum:
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
Datum:
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)
Datum:
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
Datum:
Kennt sich keiner aus?
Datum:
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)
Datum:
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... 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
Datum:
Angehängte Dateien:Hallo , Hier eine beispiel ich haben für diese treiber geschrieben. Ist mit CCS C Compiler. Tschuss :)
Datum:
Angehängte Dateien:Ich habe noch diese andere beispiel :) Fabrice.
Datum:
Diese Library unterstützt ebenfalls den SSD1289: http://henningkarlsen.com/electronics/library.php?id=51 (Arduino und ChipKit Umgebung) Oliver
Datum:
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
Datum:
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-... Gruß Micha
E-Mail-Benachrichtigung einschalten
Neu: Seitenaufteilung einschalten