[Jérémy]

Bonjour à tous ,

Je vous propose ici un programme qui utilise l’écran Proto TFT de MikroE piloté par un driver ILI9341.

- Data-Shit du driver ILI9341 : https://www.adafruit.com/datasheets/ILI9341.pdf
- Data-Shit du PIC : http://ww1.microchip.com/downloads/en/D ... 41412F.pdf
- Infos de l’écran : http://www.mikroe.com/add-on-boards/display/tft-proto/

Plutôt que de vous faire un tutoriel, long et fastidieux, je vais vous expliquer quelques règles de base qui devraient vous permettre de très vite savoir utiliser cet écran.

Question hard :

Il faut faire très attention au mode de fonctionnement. je l'utilise en mode 8bits parallèle série II , sur ma plaque d'essai easyPIC7.
Pour ce faire, Il faut veiller à bien connecter les broches IM0,IM1,IM2 et IM3. Vous trouverez le tableau des correspondances en page 26 de la DS.

- Les broches de données sont connectées sur le PORT D dans mon exemple ( cf: programme)

- Il faut bien sur brancher le rétro-éclairage avec une petite R de limitation de courant.

- Il faut veiller aussi à quelques précautions pour le tactile . en effet j'ai pas mal galérer pour réussir à trouver la subtilité. Deux broches en référence Vcc ou GND , et deux broches de lecture. Dans mon cas j'ai mis en vcc avec des R de pull-Up.

- Les autres PINs vont la où voulez, mais en numérique.


Une fois cela fait penchons-nous sur le coté soft .

Question SOFT:

Comme beaucoup de devices il va falloir initialiser notre écran .Les librairies de MikroC la dessus sont justes de l’or en barre.

-Je vous conseille fortement pour démarrer, de régler les options en mode par défaut. Une librairie existe pour cela :
TFT_Set_Default_Mode();.

- On initialise l’écran avec sa taille en pixel :
TFT_Init_ILI9341_8bit(320, 240);

- Initialiser le convertisseur anal/numérique(ADC)
ADC_Init()

- Initialiser le Touch Panel . pensez a bien déclarer les broches analogique sur lesquels vous allez lire les valeurs
TP_TFT_Init(320, 240, 0, 1); // Initialise le tactile , largeur , hauteur, X-Pin ADC (RA0), Y-Pin ADC (RA1)

- et enfin on configure la valeur de seuil ( sensibilité) de l'appui sur l’écran . Attention aussi a ne pas le mettre trop bas sinon l'écran va croire que vous êtes appuyé en permanence , ni trop haut sinon aucun appui sera valider . une valeur à 700~900 est un bon compromis , a vous de tester ce qui vous va le mieux.
TP_TFT_Set_ADC_Threshold(700);

L'écran

L'écran se pilote assez simplement grâce aux librairies . faire des traits , des ronds et des rectangles , se font de manière très intuitive. ( cf : programme).
Pas de difficulté particulière de ça côté la!

Retenez toutefois que le pen (stylo), n’agit que sur les dessins et pas sur la font, ni sur le remplissage .Si vous dessinez avec un stylo noir un rectangle et que vous le remplissez en rouge , nous verrons le contour noir.

Le coin en haut à gauche est l’origine (X=0, Y=0).
Le coin en bas à gauche (X=0, Y=240)
Le coin en haut à droite (X=320, Y=0)
Le coin en bas à droite (X=320, Y=240)

Le tactile

Le tactile mérite une calibration au départ. Le principe de la calibration se fait comme ceci:
- On demande de cliquez dans un coin de l’écran pour mesurer les valeurs analogiques max et min de ce coin.
- Le programme enregistre ces valeurs en mémoire .
- Ensuite dans le coin opposé , pour avoir les deux autres Min/Max ? et les enregistre aussi .
Ainsi l’écran sait où se situer entre ces 4 points par la suite.

Soit vous enregistrer temporairement les valeurs, mais il faudra calibrer à chaque allumage . Soit vous enregistrer les valeurs en ROM , soit vous affichez les valeurs et les rentrées manuellement.

Ensuite pour utilisez le tactile vous devrez définir des zones (rectangle ou rond) dans le lequel doit se trouver le pointeur lors d'un appui pour effectuer une fonction.
Pour détecter un appui cela se fait par la fonction : TP_TFT_Press_Detect() qui renvoie soit 0 ou 1 .
Ensuite il faut récupérer les coordonnées ou l'appui à eu lieu avec la fonction (TP_TFT_Get_Coordinates(&Xcoord, &Ycoord) == 0)

Voila pour les explication sommaires.

Voici un exemple d'utilisation .

[spoil]

Code : Tout sélectionner

/*##################################################################################
Programme de test d'un écran TFT
Fait par Jérémy sur FantasPic.fr
- Version du "27-11-2015"
- MikroC version 6.6.2
- PIC 18F46K22 cadencé a 64.mHZ Quartz 8Mhz PLL ENABLE

- Data-Shit du PIC : http://ww1.microchip.com/downloads/en/DeviceDoc/41412F.pdf
- Infos de l'ecran : http://www.mikroe.com/add-on-boards/display/tft-proto/
- Data-Shit du driver ILI9341 : https://www.adafruit.com/datasheets/ILI9341.pdf
##################################################################################*/

#include "TFT_Proto_resources.h"       // On inclut le fichier contenant nos FONTS et image

// Ici on configure les broches de l'écran
char TFT_DataPort at LATD;
char TFT_DataPort_Direction at TRISD;
sbit TFT_RST at LATB5_bit;
sbit TFT_RS at LATB2_bit;
sbit TFT_CS at LATB4_bit;
sbit TFT_RD at LATB0_bit;
sbit TFT_WR at LATB1_bit;
sbit TFT_RST_Direction at TRISB5_bit;
sbit TFT_RS_Direction at TRISB2_bit;
sbit TFT_CS_Direction at TRISB4_bit;
sbit TFT_RD_Direction at TRISB0_bit;
sbit TFT_WR_Direction at TRISB1_bit;
// Fin broche ecran

// Ici on configure les broches ou est branché la partie tactile
sbit DriveX_Left at LATA0_bit;            // pin X-  flottant
sbit DriveX_Right at LATA2_bit;           // pin X+  mis en PULL-UP
sbit DriveY_Up at LATA1_bit;              // pin Y-  flottant
sbit DriveY_Down at LATA3_bit;            // pin Y+  mis en PULL-UP
sbit DriveX_Left_Direction at TRISA0_bit;
sbit DriveX_Right_Direction at TRISA2_bit;
sbit DriveY_Up_Direction at TRISA1_bit;
sbit DriveY_Down_Direction at TRISA3_bit;
// Fin broche tactile

// Déclaration de nos variables, utilisées tout au long du programme ---------------
unsigned int Xcoord, Ycoord, i, moy_X, moy_Y, j;
unsigned int x_min, y_min, x_max, y_max;
unsigned int x_coord, y_coord;

unsigned char PenDown, bouton;
unsigned char x_pos[6];
unsigned char y_pos[6];

char x_min_msg[] = "X min:"; // TFT message
char y_min_msg[] = "Y min:";
char x_max_msg[] = "X max:";
char y_max_msg[] = "Y max:";

char x_min_val[6];      // valeur de calibration en string
char y_min_val[6];
char x_max_val[6];
char y_max_val[6];

sbit BP1 at bouton.B1;   // champ de drapeaux
sbit BP2 at bouton.B2;   // Ici je déclare 5 drapeaux depuis la variable bouton
sbit BP3 at bouton.B3;
sbit BP4 at bouton.B4;
sbit BP5 at bouton.B5;

// déclaration des PROTOTYPES       ------------------------------------------------
void Check_TP();
void Display_const();
void Initialisation();
void Calibrate();
void Trace_bouton(unsigned char numero_BP);
void animation1();
void animation2();
void mode_dessin();

//##################################################################################
//#########################      PROGRAMME PRINCIPAL       #########################
//##################################################################################
void main() {

  Initialisation();         // On initialise l'écran, l'ADC , le TP ...

                                                       //Un fois calibrer on rentre les valeurs manuellement
  TP_TFT_Set_Calibration_Consts(190, 820, 230, 675);  // pour eviter de calibrer à chaque allumage
                                                      // Elle s'obtienne apres calibration
  
  BP1 = BP2 = BP3 = BP4 = BP5 = PenDown = 0 ; // RAZ des valeurs

  animation1();
  animation2();  // On fait la petite animation au début

  TFT_Set_Font(Tahoma14x16, CL_BLACK, FO_HORIZONTAL);  // On déclare la font

  for (i=1;i<=5;i++){      // On trace les 5 boutons
      Trace_bouton(i);
   }

//#######################    BOUCLE INFINIE     ####################################
 while (1) {     // LA boucle ne fait que regarder si on appui sur lécran
      
   Check_TP();   // Regarde si on appui susr l'écran
  
 }
}

//##################################################################################
//#########################           FONCTIONS            #########################
//##################################################################################

// Fonction qui permet de dessiner sur l'ecran
void animation1(){
      TFT_Fill_Screen (CL_WHITE);     // On remplit l'écran en blanc

      // Defini la couleur et l'épaisseur du stylo pour tracer des formes
      TFT_Set_Pen(CL_BLACK, 3);      // Voir le tableau des couleurs

      // Defini la coulour et le gradient avec lequel on remplit les cercles et rectangle
      // param. d'entrée :( ( enable=1 ou disable=0  ), couleur de remplissage ,
      // (activation du gradient=1 ou désactivation=0), ( couleur du gradient de départ), (couleur du gradient d'arrivée) )
      TFT_Set_Brush(0, 0, 1, LEFT_TO_RIGHT, CL_BLACK, CL_WHITE);

      // Trace une ligne horizontale
      // Param. d'entrée : X de départ, X de fin , et Position en Y de la ligne
      TFT_H_Line(30, 110, 30);
      TFT_H_Line(30, 110, 150);
      delay_ms(500);
      // Trace une ligne verticale
      // Param. d'entrée : Y de départ, Y de fin , et Position en X de la ligne
      TFT_V_Line(30, 150, 30);
      TFT_V_Line(30, 150, 110);
      delay_ms(500);

      // trace un rectangle
      // Param. d'entrée : X du point en haut a gauche, Y du point en haut a gauche
      //                   X du point en haut a gauche, Y du point en bas à droite
      TFT_Rectangle(20, 20, 30, 200);
      delay_ms(100);
      TFT_Rectangle(30, 30, 110, 150);
      delay_ms(100);
      TFT_Rectangle(110, 30, 190, 150);
      delay_ms(100);
      TFT_Rectangle(190, 30, 270, 150);
      delay_ms(500);

      // Trace une ligne simple
      // Param. d'entrée : X de départ, Y de départ ,   X de de fin , Y de fin
      TFT_Line(20, 20, 30, 200);
      TFT_Line(20, 200, 30, 20);
      delay_ms(500);

      // Trace un cercle
      // Param. d'entrée : X du centre du cerle, Y du centre du cercle , R pour le radius
      TFT_Set_Brush(1, CL_WHITE, 1, TOP_TO_BOTTOM , CL_BLACK, CL_WHITE);
      TFT_Circle(25, 23, 6);
      delay_ms(500);

      TFT_Set_Brush(1, CL_BLUE, 0, LEFT_TO_RIGHT, CL_BLACK, CL_WHITE);
      TFT_Rectangle(30, 30, 110, 150);
      TFT_Set_Brush(1, CL_RED, 0, LEFT_TO_RIGHT, CL_BLACK, CL_WHITE);
      TFT_Rectangle(190, 30, 270, 150);
      delay_ms(500);

      // Defini la police d'ecriture
      // Param. d'entrée : ( nom de la font), (couleur de la font), (orientation)
      TFT_Set_Font(Tahoma28x35, CL_BLACK, FO_HORIZONTAL);

      // Ecrit du texte
      // Param. d'entrée : (texte), ( position en X du texte), (position en Y du texte)
      TFT_Write_Text("Aux  morts du 13/11/15 !!!", 35, 160);
      delay_ms(2000);
}

// Fonction qui permet de dessiner sur l'ecran -------------------------------------
// La fonction calcul 3 valeurs des points appuyés consécutivement et en fait la moyenne. Une fois la moyenne faite
// elle dessine un petit rond en guise de pointe de stylo !
void  mode_dessin(){

 TFT_Fill_Screen (CL_WHITE);     // On efface l'écran

 TFT_Set_Pen(CL_RED, 3);       // On dessine la croix blanche sur fond rouge
 TFT_Set_Brush(1, CL_RED, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE); //peint en rouge
 TFT_Rectangle(300, 0, 320, 20); // dessine un rectangle
 TFT_Set_Pen(CL_WHITE, 3);       // Le stylo en rouge
 TFT_Line (305,5,315,15);        //  dessine les traits de la croix
 TFT_Line (305,15,315,5);

 TFT_Set_Pen(CL_NAVY, 3);       // On dessine le bouton bleu d'effacement du dessin
 TFT_Set_Brush(1, CL_NAVY, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
 TFT_Rectangle(0, 0, 20, 20);
 TFT_Set_Pen(CL_WHITE, 3);
 TFT_Circle (10,10,4);

 TFT_Set_Pen(CL_BLACK, 3);       // Le stylo en noir
 TFT_Set_Brush(1, CL_BLACK, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE); // remplis les rond en noir
 j = 1; // RAZ du compteur

  while (BP5 == 1){
   if (TP_TFT_Press_Detect()) {  // Si l'écran est detecté comme appuyé

        if ((TP_TFT_Get_Coordinates(&Xcoord, &Ycoord) == 0)){ // Si les coordonnées sont valides ( dans le cadre designé)
           moy_X = moy_X + Xcoord;     // On calcule nos valeurs
           moy_Y = moy_Y + Ycoord;
           j++;                        // on incremente un compteur pour savoir le nombre de valeur que l'on à acquise
              if ( j >= 4){
                 j = 1;
                 moy_X = moy_X / 3;    // Arrivé à 3 valeurs calculées , on fait la moyenne
                 moy_Y = moy_Y / 3;
                 if (((moy_X > 297) && (moy_Y < 23)) || ((moy_X < 23) && (moy_Y < 23))){   // Zone d'exclusion du dessin pour ne pas effacer nos boutons
                    }
                    else TFT_Circle(moy_X, moy_Y, 1);  // on dessine notre petit cercle en guise de pointe de stylo

                 moy_X = 0;    // On RAZ notre moyenne
                 moy_Y = 0;
               }
           if ( (Xcoord>=300) && (Ycoord <= 20) && (PenDown == 0)){   // appui sur le BP de fermeture
               BP5 = 0;  // on arrete de boucler pour sortir
            }
            if ( (Xcoord<=20) && (Ycoord <= 20) && (PenDown == 0)){   // Appui sur le bouton effacement
                 TFT_Fill_Screen (CL_WHITE);                          // On efface l'écran
                                                                      // Et on redesinne nos boutons
                 TFT_Set_Pen(CL_RED, 3);   // Crois rouge de fermeture
                 TFT_Set_Brush(1, CL_RED, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
                 TFT_Rectangle(300, 0, 320, 20);
                 TFT_Set_Pen(CL_GRAY, 3);
                 TFT_Line (305,5,315,15);
                 TFT_Line (305,15,315,5);

                 TFT_Set_Pen(CL_NAVY, 3);  // Rond bleu d'effacement
                 TFT_Set_Brush(1, CL_NAVY, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
                 TFT_Rectangle(0, 0, 20, 20);
                 TFT_Set_Pen(CL_SILVER, 3);
                 TFT_Circle (10,10,4);

                 TFT_Set_Pen(CL_BLACK, 3);       // Le stylo en noir
                 TFT_Set_Brush(1, CL_BLACK, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE); // remplis les rond en noir
                 j = 1; // RAZ du compteur
            }
              PenDown = 1; // On signale que notre stylo est sur l'écran ( vu que l'on as detecté un appui)
         }



    }
   else {           // Si l'ecran n'est pas appuyé ( on a relevé le stylo)
       j = 1;       // On RAZ notrecompteur de moyenne
       moy_X = 0;   // On RAZ nos moyennes
       moy_Y = 0;
       PenDown = 0; // On signale que le stylo est levé
    }
  }
}

//----------------------------------------------------------------------------------
// Fonction Animation : Petite animation en dessinant des traits et ecriture d'un texte
void animation2(){
  TFT_Fill_Screen(CL_BLUE); // remplit l'ecran en bleu
  i=0;
 TFT_Set_Pen(CL_WHITE, 1);       // Stylo en blanc

   for (i=0;i<241;i=i+3){        // dessine les traits
       TFT_Line(0, 0, 320, i);
   }

  for (i=4;i<324;i+=4){
       TFT_Line(0, 0, 320-i, 240);
   }
 delay_ms (100);

 TFT_Set_Pen(CL_BLACK, 1);     // Stylo en noir
 TFT_Set_Font(Tahoma28x35, CL_BLACK, FO_HORIZONTAL);
 TFT_Write_Text("www.FantasPic.fr", 40, 110);  // Ecrit le texte
 delay_ms ( 1000);

 TFT_Fill_Screen(CL_GRAY);    // remplis l'écran en gris

 delay_ms ( 300);
}
//----------------------------------------------------------------------------------
// Fonction : dessine les boutons  carré sur le menu principal
// Param. d'entrée : Numero du BP que l'on doit modifier/dessiner
void Trace_bouton(unsigned char numero_BP){

   if (numero_BP == 1){   // Bouton 1 doit etre modifier
      if (BP1==1){        // Si la valeur du bouton est à 1 donc à "On"
         TFT_Set_Pen(CL_GREEN, 3); // Pinceau en vert largeur de 3
         TFT_Set_Brush(1, CL_GREEN, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE); //remplissage du rectangle en vert
         TFT_Rectangle(30, 30, 80, 80); // dessine un rectangle
         TFT_Write_Text("On", 48, 40);  // Ecrit le texte
       }
      else {                     // Si la valeur du bouton est à 0 donc à "Off"
         TFT_Set_Pen(CL_RED, 3); // Pinceau en rouge largeur de 3
         TFT_Set_Brush(1, CL_RED, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
         TFT_Rectangle(30, 30, 80, 80); // Dessine un rectangle
         TFT_Write_Text("Off", 46, 40); // Ecrit le texte
       }
      TFT_Write_Text("BP-1", 42, 60);   // Ecrit le texte
    }

   else if (numero_BP == 2){
      if (BP2==1){
         TFT_Set_Pen(CL_GREEN, 3);
         TFT_Set_Brush(1, CL_GREEN, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
         TFT_Rectangle(240, 30, 290, 80);
         TFT_Write_Text("On", 258, 40);
       }
       else{
         TFT_Set_Pen(CL_RED, 3);
         TFT_Set_Brush(1, CL_RED, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
         TFT_Rectangle(240, 30, 290, 80);
         TFT_Write_Text("Off", 256, 40);
       }
      TFT_Write_Text("BP-2", 252, 60);
    }

   else if (numero_BP == 3){
      if (BP3==1){
         TFT_Set_Pen(CL_GREEN, 3);
         TFT_Set_Brush(1, CL_GREEN, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
         TFT_Rectangle(30, 160, 80, 210);
         TFT_Write_Text("On", 48, 170);
       }
       else{
         TFT_Set_Pen(CL_RED, 3);
         TFT_Set_Brush(1, CL_RED, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
         TFT_Rectangle(30, 160, 80, 210);
         TFT_Write_Text("Off", 46, 170);
       }
      TFT_Write_Text("BP-3", 42, 190);
    }

   else if (numero_BP == 4){
      if (BP4==1){
         TFT_Set_Pen(CL_LIME, 3);
         TFT_Set_Brush(1, CL_LIME, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
         TFT_Rectangle(240, 160, 290, 210);
         TFT_Set_Pen(CL_WHITE, 3);
         TFT_Write_Text("Mode", 248, 170);
         TFT_Write_Text("calibr.", 246, 190);
         delay_ms (300);
         Calibrate();      // On va calibrer le TFT
       }
       else{
         TFT_Set_Pen(CL_BLUE, 3);
         TFT_Set_Brush(1, CL_BLUE, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
         TFT_Rectangle(240, 160, 290, 210);
         TFT_Set_Pen(CL_WHITE, 3);
         TFT_Write_Text("Mode", 248, 170);
         TFT_Write_Text("calibr.", 246, 190);
       }
    }

   else if (numero_BP == 5){
      if (BP5==1){
         TFT_Set_Pen(CL_LIME, 3);
         TFT_Set_Brush(1, CL_LIME, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
         TFT_Rectangle(135, 95, 185, 145);
         TFT_Set_Pen(CL_WHITE, 3);
         TFT_Write_Text("Mode", 143, 105);
         TFT_Write_Text("Dessin", 140, 120);
         delay_ms (300);
         mode_dessin();  // On entre dans le mode dessin
       }
       else{
         TFT_Set_Pen(CL_BLUE, 3);
         TFT_Set_Brush(1, CL_BLUE, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
         TFT_Rectangle(135, 95, 185, 145);
         TFT_Set_Pen(CL_WHITE, 3);
         TFT_Write_Text("Mode", 143, 105);
         TFT_Write_Text("Dessin", 140, 120);
        }
    }
}

//----------------------------------------------------------------------------------
// Fonction : detecte un appui sur l'ecran sur le menu principale
void Check_TP() {
  
  if (TP_TFT_Press_Detect()) {  // Si l'écran est appuyé

      if ((TP_TFT_Get_Coordinates(&Xcoord, &Ycoord) == 0)){ // Si les coordonnées sont validées

        if (Xcoord >= 30 && Xcoord<=80 && Ycoord>=30 && Ycoord<=80){// Detecte la pression du doigt est dans la position du 1er bouton
           BP1++ ; // Si oui on inverse l'etat du BP
           Trace_bouton(1); // On va dessiner le nouveau BP
         }

        else if (Xcoord >= 240 && Xcoord<=290 && Ycoord>=30 && Ycoord<=80){
           BP2++ ;
           Trace_bouton(2);
         }

        else if (Xcoord >= 30 && Xcoord<=80 && Ycoord>=160 && Ycoord<=210){
           BP3++ ;
           Trace_bouton(3);
         }

        else if ((Xcoord >= 240) && (Xcoord<=290) && (Ycoord>=160) && (Ycoord<=210)){
           BP4++ ;
           Trace_bouton(4);
              if (BP4 == 0){
                 TFT_Fill_Screen(CL_GRAY); // remplit l'ecran
                 TFT_Set_Font(TFT_defaultFont, CL_BLACK, FO_HORIZONTAL);
                 for (i=1;i<=5;i++){   // Trace les 5 boutons
                    Trace_bouton(i);
                 }
               }
         }

        else if ((Xcoord >= 135) && (Xcoord<=185) && (Ycoord>=95) && (Ycoord<=145)){
           BP5++ ;
           Trace_bouton(5);
              if (BP5 == 0){
                 TFT_Fill_Screen(CL_GRAY); // remplit l'ecran
                 TFT_Set_Font(TFT_defaultFont, CL_BLACK, FO_HORIZONTAL);
                 for (i=1;i<=5;i++){   // Trace les 5 boutons
                    Trace_bouton(i);
                 }
               }
         }

        while  (TP_TFT_Press_Detect()); // On boucle tant que l'ecran est présse pour les rebonds
     }
  }
}

//----------------------------------------------------------------------------------
// Fonction qui permet de connaitre la postion ou pointe le stylo
void Pos_pointeur (){
  TFT_Set_Font(TFT_defaultFont, CL_BLACK, FO_HORIZONTAL);   // ecrit la matrice du texte
  TFT_Write_Text("Position curseur", 1, 100);
  TFT_Write_Text("X_pos =", 5, 115);
  TFT_Write_Text("Y_pos =", 5, 130);

  TFT_Set_Pen(CL_BLACK, 1);
  TFT_Set_Brush(1, CL_RED, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE); //peint en rouge
  TFT_Rectangle(300, 0, 320, 20); // dessine un rectangle
  TFT_Set_Pen(CL_WHITE, 3);       // Le stylo en rouge
  TFT_Line (305,5,315,15);
  TFT_Line (305,15,315,5);



  while (BP4 == 1){                 // tant que le BP est sur ON on reste dans le mode
      if (TP_TFT_Press_Detect()) {  // Si l'écran est appuyé

          if ((TP_TFT_Get_Coordinates(&Xcoord, &Ycoord) == 0)){ // Si les coordonnées sont valides

                if ( (Xcoord>=300) && (Ycoord <= 20) && (PenDown == 0))  BP4 = 0;

                WordToStr(Xcoord, x_pos);   // On convertis les coordonnes en word pour les affichées
                WordToStr(Ycoord, y_pos);

                TFT_Set_Brush(1, CL_WHITE, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
                TFT_Rectangle(60, 115, 90, 145);
                TFT_Set_Font(TFT_defaultFont, CL_RED, FO_HORIZONTAL);
                TFT_Write_Text(x_pos, 60, 115); // On affcije les coordonnées
                TFT_Write_Text(y_pos, 60, 128);
                PenDown = 1;
           }
       }
       else {PenDown = 0;}
   }
}
//---------------------------------------------------------------------------------
// Fonction qui permet de calibrer notre écran en fixant les min et max de l'écran
void Calibrate() {

  TFT_Fill_Screen(CL_SILVER);        // On remplit l'écran en gris
  TP_TFT_Set_ADC_Threshold(300);     // On sensibilise l'écran avec un treshold plus petit

  TFT_Set_Font(TFT_defaultFont, CL_BLACK, FO_HORIZONTAL);    // Affichage du texte
  TFT_Write_Text("appuyer sur le rond en Haut à droite", 50, 110);

  TFT_Set_Brush(1, CL_RED, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
  TFT_Set_Pen(CL_BLACK, 3);
  TFT_Circle(314,5,5);           // Dessine un cercle  coin haut/droite
  TP_TFT_Calibrate_Min();        // Focntion de la librairie qui calibre les minimums
  Delay_ms(500);

  TFT_Set_Brush(1, CL_SILVER, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
  TFT_Set_Pen(CL_SILVER, 3);
  TFT_rectangle (195,105,280,130);
  TFT_Circle(314,5,5);
  TFT_Set_Pen(CL_BLACK, 3);
  TFT_Set_Font(TFT_defaultFont, CL_BLACK, FO_HORIZONTAL);
  TFT_Write_Text("appuyer sur le rond en Bas à gauche", 50, 110);

  TFT_Set_Brush(1, CL_RED, 0, TOP_TO_BOTTOM, CL_BLACK, CL_WHITE);
  TFT_Circle(5,234,5);
  TP_TFT_Calibrate_Max();        // Fonction qui calibre les MAX
  Delay_ms(500);

  TP_TFT_Get_Calibration_Consts(&x_min,  &x_max, &y_min, &y_max); // Enregistre et stock les valeurs
  
  TP_TFT_Set_ADC_Threshold(700);  // On remet notre threshold

  Display_const();               // On affcihe les valeurs de la calibration pour pouvoir regler dans notre programme au demarrage

  Pos_pointeur ();               // On passe en mode pointeur

}

//----------------------------------------------------------------------------------
// Fonction qui affcihe les constantes de calibration
void Display_const(){

  WordToStr(x_min, x_min_val);  // Convertis les constantes de calibration en string
  WordToStr(x_max, x_max_val);
  WordToStr(y_min, y_min_val);
  WordToStr(y_max, y_max_val);

  TFT_Fill_Screen(CL_WHITE);
  TFT_Set_Font(TFT_defaultFont, CL_RED, FO_HORIZONTAL);
  TFT_Write_Text("Constantes de calibration", 1, 1);
  TFT_Write_Text(x_min_msg, 5, 15);   // Ecrit les messages
  TFT_Write_Text(x_max_msg, 5, 30);
  TFT_Write_Text(y_min_msg, 5, 45);
  TFT_Write_Text(y_max_msg, 5, 60);

  TFT_Set_Font(TFT_defaultFont, CL_BLACK, FO_HORIZONTAL);
  TFT_Write_Text(x_min_val, 45, 15);  // Ecrit les valeurs de la calibration
  TFT_Write_Text(x_max_val, 45, 30);
  TFT_Write_Text(y_min_val, 45, 45);
  TFT_Write_Text(y_max_val, 45, 60);
}

//----------------------------------------------------------------------------------
// Initialise notre écran avant utilisation
// Parametre d'entrée : AUCUN
void Initialisation() {
  ADCON1 = 0xCF;                   // Configuration de la conversion ANALOGIQUE DIGITAL
  ADC_Init();                      // Initialise ADC
  TFT_Set_Default_Mode();          // Met l'ecran en mode par defaut
  TFT_Init_ILI9341_8bit(320, 240); // Initilaise le driver de l'écran avec la taille de celui-ci

  TP_TFT_Init(320, 240, 0, 1);     // Initialise le tactile , largeur , hauteur, X-Pin ADC (RA0), Y-Pin ADC (RA1)
  TP_TFT_Set_ADC_Threshold(700);   // Configure la valeur de seuil pour lecture ADC ( 0-1024) à regler selon vaut souhait
} 

[/spoil]

[Jérémy]

Code du Header avec les fonts : ( j'ai du enlever les font inutiles car trop volumineux pour le forum)
[spoil][code=php][/code][/spoil]

LE résultat en image :
http://www.dailymotion.com/video/x3fz0qt

[Guest]

Bonjour

Tu serais bien sympa, de nous sortir le code source de tes bibliothèques, pour ceux qui ne sont pas sous micro machin, en C ou en ASM puissent faire fonctionner ce type d’écran.
Je sens le pire arrivé

A+

[Jérémy]

Tu serais bien sympa, de nous sortir le code source de tes bibliothèques

Euh...
C'est le monde à l'envers la !! Je fais un tuto pour qu'une personne ne galère pas comme moi j'ai galérer, j'apporte une petite pierre à l'édifice et en plus je dois fournir la librairie pour d'autre langages ?

Maï tu n'es pas sérieux en disant ça hein !!???

Je vais pas m'excuser à chaque fois, parce que je travaille avec MikroC et non MPLAB ou en ASM . Si j'étais sous MPLAB tous les tuto seraient dans le format MPLAB et non MikroC. Si chacun me demande de faire son travail dans son langage j'ai pas finis .

Toute fois comme je suis dans un bon jour, voila ce que j'ai trouvé vite fait , je sais pas si ça convient à ta demande.

[spoil]

Code : Tout sélectionner

/***************************** ILI9341 (8bit) *****************************/
static void TFT_Reset_ILI9341(){
  // Hold in reset
  TFT_RST = 0;
  // Set reset pin as output
  TFT_RST_Direction = 0;

  // Enable data access
  TFT_RS = 1;
  // Set RS pin as output
  TFT_RS_Direction = 0;

  // Disable LCD
  TFT_CS = 1;
  // Set LCD CS pin as output
  TFT_CS_Direction = 0;

  TFT_RD_Direction = 0;
  TFT_WR_Direction = 0;
  TFT_RD = 1;
  TFT_WR = 1;

  Delay_100ms();
  TFT_RST = 1;
  Delay_100ms();
  Delay_100ms();

  TFT_CS = 0;
  TFT_Set_Index_Ptr(0x01);   // software reset
  Delay_5ms();
  TFT_Set_Index_Ptr(0x28);   // display off
  //---------------------------------------------------------
  TFT_Set_Index_Ptr(0xcf);
  TFT_Write_Command_Ptr(0x00);
  TFT_Write_Command_Ptr(0x83);
  TFT_Write_Command_Ptr(0x30);

  TFT_Set_Index_Ptr(0xed);
  TFT_Write_Command_Ptr(0x64);
  TFT_Write_Command_Ptr(0x03);
  TFT_Write_Command_Ptr(0x12);
  TFT_Write_Command_Ptr(0x81);

  TFT_Set_Index_Ptr(0xe8);
  TFT_Write_Command_Ptr(0x85);
  TFT_Write_Command_Ptr(0x01);
  TFT_Write_Command_Ptr(0x79);

  TFT_Set_Index_Ptr(0xcb);
  TFT_Write_Command_Ptr(0x39);
  TFT_Write_Command_Ptr(0x2c);
  TFT_Write_Command_Ptr(0x00);
  TFT_Write_Command_Ptr(0x34);
  TFT_Write_Command_Ptr(0x02);

  TFT_Set_Index_Ptr(0xf7);
  TFT_Write_Command_Ptr(0x20);

  TFT_Set_Index_Ptr(0xea);
  TFT_Write_Command_Ptr(0x00);
  TFT_Write_Command_Ptr(0x00);
  //------------power control------------------------------
  TFT_Set_Index_Ptr(0xc0);     // power control
  TFT_Write_Command_Ptr(0x26);

  TFT_Set_Index_Ptr(0xc1);     // power control
  TFT_Write_Command_Ptr(0x11);
  //--------------VCOM ---------
  TFT_Set_Index_Ptr(0xc5);     // vcom control
  TFT_Write_Command_Ptr(0x35);
  TFT_Write_Command_Ptr(0x3e);

  TFT_Set_Index_Ptr(0xc7);     // vcom control
  TFT_Write_Command_Ptr(0xbe);
  //------------memory access control------------------------
  TFT_Set_Index_Ptr(0x36);     // memory access control
  if (TFT_Disp_Rotation == 90)
    if (Is_TFT_Rotated_180())
      TFT_Write_Command_Ptr (0x88);
    else
      TFT_Write_Command_Ptr (0x48);
  else
    if (Is_TFT_Rotated_180())
      TFT_Write_Command_Ptr (0xE8);
    else
      TFT_Write_Command_Ptr (0x28);

  TFT_Set_Index_Ptr(0x3a);     // pixel format set
  TFT_Write_Command_Ptr(0x55); // 16bit/pixel
  //----------------- frame rate------------------------------
  TFT_Set_Index_Ptr(0xb1);     // frame rate
  TFT_Write_Command_Ptr(0x00);
  TFT_Write_Command_Ptr(0x1B); // 70

  //----------------Gamma---------------------------------
  TFT_Set_Index_Ptr(0xf2);     // 3Gamma Function Disable
  TFT_Write_Command_Ptr(0x08);

  TFT_Set_Index_Ptr(0x26);
  TFT_Write_Command_Ptr(0x01); // gamma set 4 gamma curve 01/02/04/08

  TFT_Set_Index_Ptr(0xE0);     // positive gamma correction
  TFT_Write_Command_Ptr(0x1f);
  TFT_Write_Command_Ptr(0x1a);
  TFT_Write_Command_Ptr(0x18);
  TFT_Write_Command_Ptr(0x0a);
  TFT_Write_Command_Ptr(0x0f);
  TFT_Write_Command_Ptr(0x06);
  TFT_Write_Command_Ptr(0x45);
  TFT_Write_Command_Ptr(0x87);
  TFT_Write_Command_Ptr(0x32);
  TFT_Write_Command_Ptr(0x0a);
  TFT_Write_Command_Ptr(0x07);
  TFT_Write_Command_Ptr(0x02);
  TFT_Write_Command_Ptr(0x07);
  TFT_Write_Command_Ptr(0x05);
  TFT_Write_Command_Ptr(0x00);

  TFT_Set_Index_Ptr(0xE1);     // negamma correction
  TFT_Write_Command_Ptr(0x00);
  TFT_Write_Command_Ptr(0x25);
  TFT_Write_Command_Ptr(0x27);
  TFT_Write_Command_Ptr(0x05);
  TFT_Write_Command_Ptr(0x10);
  TFT_Write_Command_Ptr(0x09);
  TFT_Write_Command_Ptr(0x3a);
  TFT_Write_Command_Ptr(0x78);
  TFT_Write_Command_Ptr(0x4d);
  TFT_Write_Command_Ptr(0x05);
  TFT_Write_Command_Ptr(0x18);
  TFT_Write_Command_Ptr(0x0d);
  TFT_Write_Command_Ptr(0x38);
  TFT_Write_Command_Ptr(0x3a);
  TFT_Write_Command_Ptr(0x1f);
  //--------------ddram ---------------------
  // End row and column values have to be fixed disregarding the display orientation
  // 0°, 90°, 180°, 270° change values here if display with different dimensions is used
  TFT_Set_Index_Ptr(0x2A);
  TFT_Write_Command_Ptr(0);
  TFT_Write_Command_Ptr(0);
  TFT_Write_Command_Ptr((TFT_DISP_WIDTH - 1) >> 8);
  TFT_Write_Command_Ptr(TFT_DISP_WIDTH-1);

  TFT_Set_Index_Ptr(0x2B);
  TFT_Write_Command_Ptr(0);
  TFT_Write_Command_Ptr(0);
  TFT_Write_Command_Ptr((TFT_DISP_HEIGHT - 1) >> 8);
  TFT_Write_Command_Ptr(TFT_DISP_HEIGHT-1);

  TFT_Set_Index_Ptr(0xb7);     // entry mode set
  TFT_Write_Command_Ptr(0x07);
  //-----------------display---------------------
  TFT_Set_Index_Ptr(0xb6);     // display function control
  TFT_Write_Command_Ptr(0x0a);
  TFT_Write_Command_Ptr(0x82);
  TFT_Write_Command_Ptr(0x27);
  TFT_Write_Command_Ptr(0x00);

  TFT_Set_Index_Ptr(0x11);     // sleep out
  Delay_100ms();
  TFT_Set_Index_Ptr(0x29);     // display on
  Delay_100ms();
  TFT_Set_Index_Ptr(0x2c);     // memory write
  TFT_CS = 1;
}

/**
  * @brief  Complete initializing procedure for TFT controller (ILI9341)
  * @param  display_width  : Width of display (in pixels).
  * @param  display_height : Height of display (in pixels).
  */
void TFT_Init_ILI9341_8bit(unsigned int display_width, unsigned int display_height) {
  if (Is_TFT_Set() != 1) {
    TFT_Set_Index_Ptr = TFT_Set_Index;
    TFT_Write_Command_Ptr = TFT_Write_Command;
    TFT_Write_Data_Ptr = TFT_Write_Data;
  }

  TFT_DISP_WIDTH = display_width;
  TFT_DISP_HEIGHT = display_height;
  if (display_width >= display_height)
    TFT_Disp_Rotation = 0;
  else
    TFT_Disp_Rotation = 90;

  TFT_Set_Pen(CL_BLACK, 1);
  TFT_Set_Brush(0, 0, 0, 0, 0, 0);

  TFT_Move_Cursor(0, 0);
  ExternalFontSet = 0;
  TFT_DataPort_Direction = 0;
  // Reset device
  TFT_Reset_ILI9341();
  TFT_Set_Address_Ptr = TFT_Set_Address_ILI9481;
}

/**
  * @brief  Complete initializing procedure for TFT controller (ILI9341)
  * without setting TFT_DataPort direction.
  * This procedure should be used when calls to custom TFT routines are used.
  * Must be used with TFT_Set_Active.
  * @param  display_width  : Width of display (in pixels).
  * @param  display_height : Height of display (in pixels).
  */
void TFT_Init_ILI9341_8bit_Custom(unsigned int display_width, unsigned int display_height) {
  if (Is_TFT_Set() != 1) {
    TFT_Set_Index_Ptr = TFT_Set_Index;
    TFT_Write_Command_Ptr = TFT_Write_Command;
    TFT_Write_Data_Ptr = TFT_Write_Data;
  }

  TFT_DISP_WIDTH = display_width;
  TFT_DISP_HEIGHT = display_height;
  if (display_width >= display_height)
    TFT_Disp_Rotation = 0;
  else
    TFT_Disp_Rotation = 90;

  TFT_Set_Pen(CL_BLACK, 1);
  TFT_Set_Brush(0, 0, 0, 0, 0, 0);

  TFT_Move_Cursor(0, 0);
  ExternalFontSet = 0;
  // Reset device
  TFT_Reset_ILI9341();
  TFT_Set_Address_Ptr = TFT_Set_Address_ILI9481;
}
/*************************** eof ILI9341 (8bit) ***************************/

[/spoil]

Toutes les libraireis MikroC sont disponibles ici, faut chercher un peu :

Libstock

Les tutos en MPLAB et ASM sont le bienvenus par d'autre que moi , bien entendu, c'est un forum de partage ! Si chacun apporte un peu, on peut faire quelques choses de sympa

[Guest]

NON je suis sérieux et pour cause le lien que tu nous donnes ( merci) après décompression nous donne comme extension *.MCL donc inutilisable pour nous. Peut-être pour toi avec micro machin.Donc oui pour le tuto c'est sympa mais accessible pour tous sinon a quoi sert TON tuto ??. je pressentais le pire il est LA

Pour ta galère je crois avoir participe largement ,donc merci a toi pour ton retour c'est très sympa c'est ce que l'on appel entraide , et encore merci pour ton bon jour et tes quelques lignes de code je suppose que c'est l'int

[Jérémy]

NON je suis sérieux et pour cause le lien que tu nous donnes ( merci) après décompression nous donne comme extension *.MCL donc inutilisable pour nous.

effectivement ! ce n'est pas lisible même pour moi avec notepad. Donc cela doit s'ouvrir avec mikroC ,je pense.

Code : Tout sélectionner


mais accessible pour tous sinon a quoi sert TON tuto ??.

Pour ceux qui utilisent mikroC Je travaille avec ça !

Pour ta galère je crois avoir participe largement

oui nous avons pas mal bossé la dessus ensemble et je t'en remercie

tes quelques lignes de code je suppose que c'est l'int

Oui effectivement !

ceci me parait plus un peu mieux, en fait le fcihiers et coupé en plusieurs morceaux, et j'ai donné l'initialisation .

Code : Tout sélectionner

#include <built_in.h>
// Externs
extern sfr sbit TFT_RST_Direction, TFT_RST, TFT_RS_Direction, TFT_RS, TFT_CS_Direction, TFT_CS, TFT_WR, TFT_RD, TFT_WR_Direction, TFT_RD_Direction;
extern sfr unsigned short TFT_DataPort, TFT_DataPort_Direction;

static char TFT_Rotated_180 = 0;
static unsigned char TFT_Disp_Rotation = 0;
const  char TFT_NOT_ROTATED = 0;
const  char TFT_ROTATED180  = 1;

#define TFT_Write_Strobe()  TFT_WR = 0; asm nop; TFT_WR = 1;

/**
  * @brief  Reads weather display has been rotated 180 degrees or not.
  * @retval The values can be : 0 - Display not rotated (working in 0° or 90° orientation)
  *                             1 - Display rotated     (working in 180° or 270° orientation)
  */
char Is_TFT_Rotated_180() {
  return TFT_Rotated_180;
}

/**
  * @brief  Sets display 180° rotation or not.
  * @param  Arotate : The values can be : TFT_NOT_ROTATED - Display not rotated, working in 0° or 90° orientation (depending on TFT_Disp_Rotation)
  *                                       TFT_ROTATED180  - Display rotated, working in 180° or 270° orientation (depending on TFT_Disp_Rotation)
  */
void TFT_Rotate_180(char Arotate){
  TFT_Rotated_180 = Arotate;
}

/**
  * @brief  Sets controllers register address to be written in next cycle.
  * @param  index : The values can be in [0x00 - 0xFF] range
  */
void TFT_Set_Index(unsigned short index) {
  TFT_RS = 0;
  TFT_DataPort = index;
  TFT_Write_Strobe();
}

/**
  * @brief  Sets value of controller register (address must be previously defined with TFT_Set_Index)
  * @param  cmd : The values can be in [0x00 - 0xFF] range
  */
void TFT_Write_Command(unsigned short cmd) {
  TFT_RS = 1;
  TFT_DataPort = cmd;
  TFT_Write_Strobe();
}

/**
  * @brief  Sets address and value of controller register
  * @param  index : Address of controller register. Values can be in [0x00 - 0xFF] range
  * @param  value : Value of controller register. Values can be in [0x00 - 0xFF] range
  */
void TFT_Set_Reg(unsigned short index, unsigned short value) { // BYTE u mplab-u je nas unsigned short   MŽ 20100208
  TFT_CS = 0;
  TFT_Set_Index_Ptr(index);
  TFT_Write_Command_Ptr(value);
  TFT_CS = 1;
}

/**
  * @brief  Configures sets of TFT controllers register to work with parameters
  *         assigneg in TFT_Init. Also it resets the TFT controller.
  */
static void TFT_Reset_Device() {
  // Hold in reset
  TFT_RST = 0;
  // Set reset pin as output
  TFT_RST_Direction = 0;

  // Enable data access
  TFT_RS = 1;
  // Set RS pin as output
  TFT_RS_Direction = 0;

  // Disable LCD
  TFT_CS = 1;
  // Set LCD CS pin as output
  TFT_CS_Direction = 0;

  TFT_RD_Direction = 0;
  TFT_WR_Direction = 0;
  TFT_RD = 1;
  TFT_WR = 1;

  // Release from reset
  Delay_100ms();
  TFT_RST = 1;
  Delay_100ms();
  Delay_100ms();

  // Driving ability setting
  TFT_Set_Reg(0xEA, 0x00); // PTBA[15:8]
  TFT_Set_Reg(0xEB, 0x20); // PTBA[7:0]
  TFT_Set_Reg(0xEC, 0x0C); // STBA[15:8]
  TFT_Set_Reg(0xED, 0xC4); // STBA[7:0]
  TFT_Set_Reg(0xE8, 0x40); // OPON[7:0]
  TFT_Set_Reg(0xE9, 0x38); // OPON1[7:0]
  TFT_Set_Reg(0xF1, 0x01); // OTPS1B
  TFT_Set_Reg(0xF2, 0x10); // GEN
  TFT_Set_Reg(0x27, 0xA3);

  // Gamma 2.8 setting
  TFT_Set_Reg(0x40, 0x00); //
  TFT_Set_Reg(0x41, 0x00); //
  TFT_Set_Reg(0x42, 0x01); //
  TFT_Set_Reg(0x43, 0x13); //
  TFT_Set_Reg(0x44, 0x10); //
  TFT_Set_Reg(0x45, 0x26); //
  TFT_Set_Reg(0x46, 0x08); //
  TFT_Set_Reg(0x47, 0x51); //
  TFT_Set_Reg(0x48, 0x02); //
  TFT_Set_Reg(0x49, 0x12); //
  TFT_Set_Reg(0x4A, 0x18); //
  TFT_Set_Reg(0x4B, 0x19); //
  TFT_Set_Reg(0x4C, 0x14); //

  TFT_Set_Reg(0x50, 0x19); //
  TFT_Set_Reg(0x51, 0x2F); //
  TFT_Set_Reg(0x52, 0x2C); //
  TFT_Set_Reg(0x53, 0x3E); //
  TFT_Set_Reg(0x54, 0x3F); //
  TFT_Set_Reg(0x55, 0x3F); //
  TFT_Set_Reg(0x56, 0x2E); //
  TFT_Set_Reg(0x57, 0x77); //
  TFT_Set_Reg(0x58, 0x0B); //
  TFT_Set_Reg(0x59, 0x06); //
  TFT_Set_Reg(0x5A, 0x07); //
  TFT_Set_Reg(0x5B, 0x0D); //
  TFT_Set_Reg(0x5C, 0x1D); //
  TFT_Set_Reg(0x5D, 0xCC); //

  // Window setting
  if (TFT_Disp_Rotation == 90) {
    TFT_Set_Reg(0x04, 0x00);
    TFT_Set_Reg(0x05, 0xEF);
    TFT_Set_Reg(0x08, 0x01);
    TFT_Set_Reg(0x09, 0x3F);
  } else {
    TFT_Set_Reg(0x04, 0x01);
    TFT_Set_Reg(0x05, 0x3F);
    TFT_Set_Reg(0x08, 0x00);
    TFT_Set_Reg(0x09, 0xEF);
  }

  if (TFT_Disp_Rotation == 90)
    if (Is_TFT_Rotated_180())
      TFT_Set_Reg(0x16, 0xC8); // MY=1, MX=1, MV=0, BGR=1
    else
      TFT_Set_Reg(0x16, 0x08); // MY=0, MX=0, MV=0, BGR=1
  else
    if (Is_TFT_Rotated_180())
      TFT_Set_Reg(0x16, 0xA8); // MY=0, MX=1, MV=1, BGR=1
    else
      TFT_Set_Reg(0x16, 0x68); // MY=1, MX=0, MV=1, BGR=1

  // Power Voltage Setting
  TFT_Set_Reg(0x1B, 0x1B); // VRH = 4.65
  TFT_Set_Reg(0x1A, 0x01); // BT
  TFT_Set_Reg(0x24, 0x2F); // VMH
  TFT_Set_Reg(0x25, 0x57); // VML

  // Vcom offset
  TFT_Set_Reg(0x23, 0x8D); // FLICKER ADJUST

  // Power ON Setting
  TFT_Set_Reg(0x18, 0x36);
  TFT_Set_Reg(0x19, 0x01);
  TFT_Set_Reg(0x01, 0x00);
  TFT_Set_Reg(0x1F, 0x88);
  Delay_5ms();
  TFT_Set_Reg(0x1F, 0x80);
  Delay_5ms();
  TFT_Set_Reg(0x1F, 0x90);
  Delay_5ms();
  TFT_Set_Reg(0x1F, 0xD0);
  Delay_5ms();
  // 65K Color Selection
  TFT_Set_Reg(0x17, 0x05);
  // Set Panel
  TFT_Set_Reg(0x36, 0x00); // Panel characteristic control register
  // Display ON Setting
  TFT_Set_Reg(0x28, 0x38);
  Delay_10ms();
  Delay_10ms();
  Delay_10ms();
  Delay_10ms();
  TFT_Set_Reg(0x28, 0x3C);
}

/**
  * @brief  Move cursor to designated coordinates, in preparation for drawing on display.
  * @param  x : X coordinate. Range shoud be [0 - TFT_DISP_WIDTH-1]
  * @param  y : Y coordinate. Range shoud be [0 - TFT_DISP_HEIGHT-1]
  */
static void TFT_Set_Address(unsigned int x, unsigned int y) {
  TFT_Set_Index_Ptr(0x02);
  TFT_Write_Command_Ptr(x>>8);
  TFT_Set_Index_Ptr(0x03);
  TFT_Write_Command_Ptr(x);
  TFT_Set_Index_Ptr(0x06);
  TFT_Write_Command_Ptr(y>>8);
  TFT_Set_Index_Ptr(0x07);
  TFT_Write_Command_Ptr(y);
  TFT_Set_Index_Ptr(0x22);
}

/**
  * @brief  Write 16bit value on TFT Data bus. This is 8bit communication
  *         so it is done in two cycles. This should be used when working with
  *         TFT controller in 8bit mode.
  * @param  _data : Data to be transfered. Range values [0x00 - 0xFFFF]
  */
void TFT_Write_Data(unsigned int _data) {
  TFT_RS = 1;
  TFT_DataPort = Hi(_data);
  TFT_Write_Strobe();
  TFT_DataPort = Lo(_data);
  TFT_Write_Strobe();
}

/**
  * @brief  Complete initializing procedure for TFT controller (HX8347D)
  * @param  display_width  : Width of display (in pixels).
  * @param  display_height : Height of display (in pixels).
  */
void TFT_Init(unsigned int display_width, unsigned int display_height) {
  if (Is_TFT_Set() != 1) {
    TFT_Set_Index_Ptr = TFT_Set_Index;
    TFT_Write_Command_Ptr = TFT_Write_Command;
    TFT_Write_Data_Ptr = TFT_Write_Data;
  }

  TFT_DISP_WIDTH = display_width;
  TFT_DISP_HEIGHT = display_height;
  if (display_width >= display_height)
    TFT_Disp_Rotation = 0;
  else
    TFT_Disp_Rotation = 90;

  TFT_Set_Pen(CL_BLACK, 1);
  TFT_Set_Brush(0, 0, 0, 0, 0, 0);

  TFT_Move_Cursor(0, 0);
  ExternalFontSet = 0;
  // Set DataPort as Output
  TFT_DataPort_Direction = 0;
  // Reset device
  TFT_Reset_Device();
  TFT_Set_Address_Ptr = TFT_Set_Address;
}

/**
  * @brief  Complete initializing procedure for TFT controller (HX8347D)
  * without setting TFT_DataPort direction.
  * This procedure should be used when calls to custom TFT routines are used.
  * Must be used with TFT_Set_Active.
  * @param  display_width  : Width of display (in pixels).
  * @param  display_height : Height of display (in pixels).
  */
void TFT_Init_Custom(unsigned int display_width, unsigned int display_height) {
  if (Is_TFT_Set() != 1) {
    TFT_Set_Index_Ptr = TFT_Set_Index;
    TFT_Write_Command_Ptr = TFT_Write_Command;
    TFT_Write_Data_Ptr = TFT_Write_Data;
  }

  TFT_DISP_WIDTH = display_width;
  TFT_DISP_HEIGHT = display_height;
  if (display_width >= display_height)
    TFT_Disp_Rotation = 0;
  else
    TFT_Disp_Rotation = 90;

  TFT_Set_Pen(CL_BLACK, 1);
  TFT_Set_Brush(0, 0, 0, 0, 0, 0);

  TFT_Move_Cursor(0, 0);
  ExternalFontSet = 0;
  // Reset device
  TFT_Reset_Device();
  TFT_Set_Address_Ptr = TFT_Set_Address;
}


Le fichier en entier

__Lib_TFT_Defs.rar

[Guest]

Bonjour

Le PIRE est la, soit tu passes par la case MICROC et tu banques ,soit tu n'as pas accès aux biblio.et bientôt ils vont signer la fin de la partie.

VOUS NE POUVEZ PAS UTILISER CETTE BIBLIOTHÈQUE VOTRE LICENCE N'EST PAS A JOUR VEUILLEZ INSÉRER VOTRE CARTE BANCAIRE.

Donc concrètement on ne peut pas utiliser ton TFT .

un conseil jeremy regarde ailleurs que chez micro machin." il une dizaine d'année je me suis fais ma propre biblio pour le KS0107B cercle, ovale, rectangle pixel, remplissage, matrice de caractères ..., bien sur en ASM pour 18F" fait de même monte tes propres biblio je sais un boulot de fou,pour les habitués des langages évolués, mais je me suis régalé, le pied

A+

PS merci pour le fichier joint

[Jérémy]

hello,

???!!! tu sais je reste un gros novice . Au départ quand on à planché sur le premier TFT, on était en train de la créer la librairie !Maintenant quelqu'un c'est farci tout le travail et le met à disposition, j'en profite.
Je ne comprends pas. Je t'ai filé la librairie normalement non ? tu l'ouvre avec notepad++ et le tour est joué, tu peux voir ce qu'il faut faire non ?
Après il me parait logique que tu ne puisse pas utiliser cette librairie avec d'autre langage et/ou logiciel que MikroC.
Je ne vois pas ou est le probléme ?

C'est pareil que d'acheter des barres de coffre de toit pour Peugeot ou Renault ; les une vont pas sur les autres et vice versa. Mais le principe est le même.

Tu peut utiliser ce TFT en adaptant la librairie MikroC avec ton langage.

PS: STP arrête ces polémiques nauséabondes sur MikroC et MPLAB et l'ASM.

[Guest]

hello,

???!!! tu sais je reste un gros novice . Au départ quand on à planché sur le premier TFT, on était en train de la créer la librairie !Maintenant quelqu'un c'est farci tout le travail et le met à disposition, j'en profite.

c'est tres bien , j'ai jamais dit le contraire. Je t'invite seulement a faire toi meme tes lib .C’était d’ailleurs un simple conseil après a toi de voir

Je ne comprends pas. Je t'ai filé la librairie normalement non ? tu l'ouvre avec notepad++ et le tour est joué, tu peux voir ce qu'il faut faire non ?
Après il me parait logique que tu ne puisse pas utiliser cette librairie avec d'autre langage et/ou logiciel que MikroC.
Je ne vois pas ou est le probléme ?

C'est pareil que d'acheter des barres de coffre de toit pour Peugeot ou Renault ; les une vont pas sur les autres et vice versa. Mais le principe est le même.

Tu peut utiliser ce TFT en adaptant la librairie MikroC avec ton langage.

il n'y a pas de problème je dois pouvoir faire cela en C ou en ASM , car AMHA on était pas loin de conclure sur l'init dommage que tu es détruit le TFT

PS: STP arrête ces polémiques nauséabondes sur MikroC et MPLAB et l'ASM.

Pas du tout un simple constat, pour faire du langage évolué il va falloir sortir le porte monnaie.Je le comprends très bien et cela ne vas pas s'arranger.

[manu_espagne]

Bonsoir Jeremy,

Je suis Emmanuel, étudiant en genie electrique à la faculté des sciences de toulouse. J'essaye de faire fonctionner ton projet écran TFT proto tactile avec driver ILI 9341. Je débute avec le langage C. Pour me simplifier la tache , pourrais tu m'envoyer par mail, l'ensemble des fichiers .c et .h nécessaires au bon fonctionnement de ce projet et les fichiers de fonts mon mail: viratelemmanuel@yahoo.fr

merci d'avance à toi et bonne soirée

PS: tu habites en région toulousaine?

Emmanuel