void traceTouche (int xo, int yo, int taille, int couleur) {

    lcd.fillRect ((xo–(taille/2)),(yo–(taille/2)),(xo+(taille/2)),(yo+(taille/2)),couleur);

}
 

// — Programme Arduino —
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 20/10/2010.

// ——- Licence du code de ce programme —–
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// ——– Que fait ce programme ? ———
 /* Ce programme teste l’émulation
 d’un clavier 16 touches
sur le touchpad de l’écran. */

// — Fonctionnalités utilisées —

// Utilise adaptateur pour écran MI0283QT2 240×320 pixels – 262 K couleurs
// Utilise le touchpad ADS7846 intégré de l’écran MI0283QT2

// ——– Circuit à réaliser ———

// Connexions à réaliser pour adaptateur écran MI0283QT2 240×320 pixels – 262 K couleurs
// ces connexions sont réalisées automatiquement si utilisation du circuit imprimé mSD-shield

// —– broches utilisées pour le contrôle de l’afficheur graphique
// broche CS de l’adaptateur sur la broche 7
// broche RST de l’adaptateur sur la broche 8
// broche LED de l’adaptateur sur la broche 9

// —– broches utilisées pour la communication SPI de l’adaptateur MI0283QT2
// broche SDI de l’adaptateur sur la broche 11
// broche SDO de l’adaptateur sur la broche 12
// broche SCL de l’adaptateur sur la broche 13

// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles…

// — Déclaration des constantes —

// — Inclusion des librairies —
#include <MI0283QT2.h> // librairie de l’afficheur TFT MI0283QT2
// Avant utilisation, faut installer manuellement cette librairie
// dans le dossier <Libraries> du dossier Arduino

#include <ADS7846.h> // inclusion de la librairie pour le touchpad
// Avant utilisation, faut installer manuellement cette librairie
// dans le dossier <Libraries> du dossier Arduino
#define TOUCHPAD_EEPROMADDR (0x00) //adresse eeprom des données de calibration du touchpad

// — Déclaration des constantes des broches E/S numériques —

// — Déclaration des constantes des broches analogiques —

// — Déclaration des variables globales —

//—– pixel central —–
int xo;
int yo;

int X, Y; // variables acquisition touchpad

int taille=50; // largeur de la touche
int ecart=8; // ecart entre les touches
const int nombreLignes=4; // nombre de lignes
const int nombreColonnes=4; // nombre de lignes

// clavier 4×4 = 4 x50 + 5×8 = 240

char touches[nombreLignes][nombreColonnes] = {
  {‘1’,‘2’,‘3’,‘+’},
  {‘4’,‘5’,‘6’,‘-‘},
  {‘7’,‘8’,‘9’,‘*’},
  {‘.’,‘0’,‘=’,‘/’}
};

/*
byte touches[nombreLignes][nombreColonnes] = {
  {1,2,3,10},
  {4,5,6,11},
  {7,8,9,12},
  {13,0,14,15}
};
*/

int testX, testY; // variable de test pour les touches
int appui; // mémorise si un appui a eu lieu

int xref=1–1, yref=88–1; // coordonnée coin sup gauche du clavier

int ligne, colonne; // variables de ligne et de colonne
int ligneSelect, colonneSelect; // variables de ligne et colonne sélectionnée

int posX=0, posXo=0; // position X du texte

int valeur=0;
long valeurSaisie=0; // valeur saisie

// — Déclaration des objets utiles pour les fonctionnalités utilisées —

MI0283QT2 lcd; // création d’un objet de type MI0283QT2 appelé lcd

ADS7846 touchpad; // création un objet touchpad de type ADS7846

// ////////////////////////// 2. FONCTION SETUP = Code d’initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// — ici instructions à exécuter 1 seule fois au démarrage du programme —

// ——- Initialisation fonctionnalités utilisées ——-  

//initialisation écran MI0283QT2  240×320 pixels
lcd.init(4); //spi-clk = Fcpu/4
lcd.clear(RGB(255,255,255)); // efface ecran en blanc

//—- initialisation du touchpad de l’afficheur
touchpad.init(); // initialisation du Touchpad
touchpad_calibration(); // appelle la fonction de calibration du touchpad – voir code après fonction loop

//configuration écran MI0283QT2  240×320 pixels – après calibrage touchpad
lcd.setOrientation(270); // configure orientation afficheur en degrés : 0,90,180,270
// Par défaut 0 = point 0,0 en regard connecteur USB

lcd.clear(RGB(255,255,255)); // efface ecran en blanc
lcd.led(50); // fixe luminosité

//—- configuration du touchpad de l’afficheur  – après calibrage touchpad
touchpad.setOrientation(270); // configure orientation touchpad en degrés : 0,90,180,270
// Par défaut 0 = point 0,0 en regard connecteur USB
// IMPORTANT : touchpad et afficheur doivent avoir la meme orientation !

// ——- Broches en sorties numériques ——-  

// ——- Broches en entrées numériques ——-  

// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-  

//——- initialisation des variables utilisées
//xo=lcd.getWidth()/2;
//yo=lcd.getHeight()/2;

// ——- tracé de la touche centrale

// rectangle de largeur = taille et centré sur xo,yo
//lcd.drawRect ((xo-(taille/2)),(yo-(taille/2)),(xo+(taille/2)),(yo+(taille/2)),bleu);
//lcd.fillRect ((xo-(taille/2)),(yo-(taille/2)),(xo+(taille/2)),(yo+(taille/2)),bleu);

// —– tracé initial du clavier ——

for ( ligne=1; ligne<=nombreLignes; ligne++) { // tracé des lignes

  for ( colonne=1; colonne<=nombreColonnes; colonne++) { // tracé des colonnes

    xo=xref+ecart+(taille/2)+((ecart+taille)*(colonne–1));// calcule coordonnée x centre touche
    yo=yref+(taille/2)+((taille+ecart)*(ligne–1));// calcule coordonnée y centre touche

    traceTouche(xo, yo, taille, bleu); // trace la touche

    // touche de 0 à 9 => affiche le chiffre
    /*if (touches[ligne-1][colonne-1] <10)(lcd.drawText(xo-4,yo-4,touches[ligne-1][colonne-1],1,jaune,bleu));
    if (touches[ligne-1][colonne-1]==10)(lcd.drawText(xo-4,yo-4,’+’,1,jaune,bleu));
    if (touches[ligne-1][colonne-1]==11)(lcd.drawText(xo-4,yo-4,’-‘,1,jaune,bleu));
    if (touches[ligne-1][colonne-1]==12)(lcd.drawText(xo-4,yo-4,’/’,1,jaune,bleu));
    if (touches[ligne-1][colonne-1]==15)(lcd.drawChar(xo-4,yo-4,’*’,1,jaune,bleu));
    if (touches[ligne-1][colonne-1]==13)(lcd.drawText(xo-4,yo-4,’.’,1,jaune,bleu));
    if (touches[ligne-1][colonne-1]==13)(lcd.drawText(xo-4,yo-4,’=’,1,jaune,bleu));  
    */
  } // fin for colonnes

} // fin for lignes

} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension

void loop(){ // debut de la fonction loop()

// — ici instructions à exécuter par le programme principal —

touchpad.service(); // appel de la routine service touchpad

if (touchpad.getPressure()>10){ // si appui touchpad

   // analyse si appui dans la touche
   X=touchpad.getX(), Y=touchpad.getY();

  // —– passe en revue les touches du clavier ——

  for (ligne=1; ligne<=nombreLignes; ligne++) { // boucle des lignes

    for (colonne=1; colonne<=nombreColonnes; colonne++) { // boucle des colonnes

      xo=xref+ecart+(taille/2)+((ecart+taille)*(colonne–1));// calcule coordonnée x centre touche
      yo=yref+(taille/2)+((taille+ecart)*(ligne–1));// calcule coordonnée y centre touche

     //—- vérifie si appui dans la touche ———
     testX=abs(X–xo); // calcul valeur absolue de l’écart de X touchpad à xo centre trouche
     testY=abs(Y–yo); // calcul valeur absolue de l’écart de Y touchpad à yo centre trouche

      //traceTouche(xo, yo, taille, bleu); // trace la touche

       if (testX<taille/2 && testY<taille/2) { // si appui dans la touche

      //— touche en rouge —
      //lcd.fillRect ((xo-(taille/2)),(yo-(taille/2)),(xo+(taille/2)),(yo+(taille/2)),rouge);
      traceTouche(xo, yo, taille, rouge); // trace la touche

      appui=1; // mémorise un appui a eu lieu
      lcd.drawText(0, 0, « Appui sur touche », 1, rouge, blanc); // affiche message

      lcd.drawText(0,10, »                          « ,1,vert,blanc); // efface affichage précédent
      lcd.drawText(0,10,« xo= »,1,rouge,blanc),lcd.drawText(30,10,xo,1,rouge,blanc);
      lcd.drawText(0,20, »                          « ,1,vert,blanc); // efface affichage précédent
      lcd.drawText(0,20,« yo= »,1,rouge,blanc),lcd.drawText(30,20,yo,1,rouge,blanc);

      ligneSelect=ligne;
      colonneSelect=colonne;      
      delay(250); // anti-rebond

      break; // sort de for si touche trouvée

       } // fin if testX

    } // fin for colonnes

    if (appui==1) break; // sort de la seconde boucle si touche trouvée

  } // fin for lignes

   //+++++++++++++ analyse de la touche saisie +++++++++++++

   //—– affiche le caractère de touche saisi —-
    posXo=posX; // pour position d’affichage commune
    posX=lcd.drawChar(posXo,55,touches[ligneSelect–1][colonneSelect–1],2,jaune,noir);

    //—- affiche la valeur numerique correspondante
    valeur=touches[ligneSelect–1][colonneSelect–1]–48; // transforme ASCII en valeur numérique
    lcd.drawText(posXo,70,valeur,1,bleu,jaune);

    //—- affiche la valeur numerique entiere Saisie
    valeurSaisie=(valeurSaisie*10)+valeur; // x10 et ajoute unité
    lcd.drawText(0,78,valeurSaisie,1,bleu,jaune);

   //touchpad.service(); // appel de la routine service touchpad

} //fin touchpad.getPressure()>10

else {

// —- sinon touche en  bleu si pas fait depuis qu’un appui a eu lieu —
// — pour éviter de le refaire si déjà bleu —

  if (appui==1) {
    //lcd.fillRect ((xo-(taille/2)),(yo-(taille/2)),(xo+(taille/2)),(yo+(taille/2)),bleu);

      xo=xref+ecart+(taille/2)+((ecart+taille)*(colonneSelect–1));// calcule coordonnée x centre touche
      yo=yref+(taille/2)+((taille+ecart)*(ligneSelect–1));// calcule coordonnée y centre touche

    traceTouche(xo, yo, taille, bleu); // trace la touche
    appui=0; // mémorise appui pris en compte
    lcd.drawText(0, 0,  »                   « , 1, rouge, blanc); // efface message

      lcd.drawText(0,30, »                          « ,1,vert,blanc); // efface affichage précédent
      lcd.drawText(0,30,« xo= »,1,vert,blanc),lcd.drawText(30,30,xo,1,vert,blanc);
      lcd.drawText(0,40, »                          « ,1,vert,blanc); // efface affichage précédent
      lcd.drawText(0,40,« yo= »,1,vert,blanc),lcd.drawText(30,40,yo,1,vert,blanc);

    // touchpad.service(); // appel de la routine service touchpad
  }

}

} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////

// —- fonction traceTouche —
// — trace une touche de la taille voulue à partir des coordonnées xo, yo du centre de la touche
void traceTouche (int xo, int yo, int taille, int couleur) {

    lcd.fillRect ((xo–(taille/2)),(yo–(taille/2)),(xo+(taille/2)),(yo+(taille/2)),couleur);

    //—– trace le caractère de touche correspondant à partir du tableau touches[nombreLignes][nombreColonnes]
    lcd.drawChar(xo–8,yo–8,touches[ligne–1][colonne–1],2,jaune,couleur);

}

//—- fonction de calibration du touchpad
void touchpad_calibration(void) {

  int i; // variable locale utilisée par la fonction

  // crée un tableau des 3 points de calibration pour le LCD
  // le type CAL_POINT est une structure de 2 long x et y
  // les valeurs CAL_POINT_X1, CAL_POINT_Y1, etc… sont préfinies cf ADS7846.h
  CAL_POINT lcd_points[3] = {{CAL_POINT_X1,CAL_POINT_Y1},
                             {CAL_POINT_X2,CAL_POINT_Y2},
                            {CAL_POINT_X3,CAL_POINT_Y3}};

 // crée un tableau de 3 points de calibration pour le touchpad
 CAL_POINT touchpad_points[3], *p;

  // si des données de calibration existent déjà, sort de la fonction de calibration
  // réalise calibration uniquement au premier lancement programme
  // Le nombre d’écriture en EEPROM est limité : on pourra donc calibrer le touchpad uniquement au premier lancement
// décommenter la condition suivante pour éviter de calibrer à chaque fois
  if(touchpad.readCalibration(TOUCHPAD_EEPROMADDR)) {
    return;
  }

  // répète tant que pas prise en compte de 3 appuis – 1 appui pour chaque point de calibration
  i = 0;
  do {

    //affiche le point de calibration pour la valeur de i (affiche 3 cercles)
    lcd.drawCircle(lcd_points[i].x, lcd_points[i].y, 1, RGB(0,0,255)); // mini cercle bleu au point de calibration courant
    lcd.drawCircle(lcd_points[i].x, lcd_points[i].y, 4, RGB(0,255,0)); // petit cercle vert centré sur point calibration courant
    lcd.drawCircle(lcd_points[i].x, lcd_points[i].y, 8, RGB(255,0,0));// cercle rouge centré sur point calibration courant

    touchpad.service(); // lance la fonction de service du touchpad
    // acquisition des coordonnées x,y et pressure si appui – modif des variables public

    if(touchpad.getPressure() > 5) { // si la pression sur le touchpad supérieure à 5 = si un appui a eu lieu
      touchpad_points[i].x = touchpad.getXraw(); // mémorise la valeur X renvoyée par le touchpad non calibré
      touchpad_points[i].y = touchpad.getYraw(); // mémorise la valeur Y renvoyée par le touchpad non calibré
      i++; // incrémente i seulement si un appui a eu lieu.. l’appel de service se fait en boucle si pas appui
      lcd.clear(RGB(255,255,255)); // efface l’écran en blanc entre chaque point de calibration
    } // fin if getPressure() > 5

  }while(i<3); // répète lecture touchpad tant que pas 3 appuis – 1 pour chaque point de calibration

  //calcule la calibration du touchpad en faisant correspondre les valeurs X,Y du lcd
  // et les valeurs X,Y du touchpad obtenues à l’aide des points de calibration
  touchpad.setCalibration(lcd_points, touchpad_points);

  // enregistre en eeprom la matrice des valeurs de calibration du touchpad
  // la calibration est mémorisée meme après mise hors tension de la carte Arduino
  touchpad.writeCalibration(TOUCHPAD_EEPROMADDR);
  // Le nombre d’écriture en EEPROM est limité : on pourra donc calibrer le touchpad uniquement au premier lancement

} //——————- fin fonction calibration touchpad ————-

// ////////////////////////// Fin du programme ////////////////////

// ////////////////////////// Mémo instructions ////////////////////
// —- mémo librairie pour écran MI0283QT2 240×320 pixels – 262 K couleurs
//lcd.init(4); //spi-clk = Fcpu/4
//lcd.setOrientation(0); // configure orientation afficheur en degrés : 0,90,180,270
//lcd.clear(color);
//lcd.led(50); // fixe luminosité 0-100

// lcd.drawChar( x,  y,  ‘L’,  size,  color,  bg_color);
// lcd.drawText(x, y, « chaine », size, color, bg_color);
// lcd.drawTextPGM(x, y, PSTR(« string »), size, color, bg_color)
// lcd.drawInteger(x0, y0, integerNumber, base, size, color, bg_color);
// lcd.drawFloat( x0, y0, number, digits, size,  color,  bg_color)

// lcd.drawPixel(x, y, color);
// lcd.drawRect(x0, y0, x1, y1, color);

// Mémo librairie touchpad ADS7846 intégré de l’écran MI0283QT2

//touchpad.setOrientation(angle);

//touchpad.service();
//touchpad.getPressure()
//touchpad.getX();
//touchpad.getY();

// ////////////////////////// Fin Mémo instructions ////////////////////