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
}