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 crée une calculatrice
 avec  émulation
 d’un clavier 16 touches
 sur le touchpad de l’afficheur.
*/

// — 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’,‘x’},
  {‘.’,‘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 valeur=0;
long valeurSaisie[2]={0,0}; // tableau des valeurs saisies, indice 0 et 1
int indice=0; // indice valeur saisie
long resultat=0; // variable resultat operation

int debord=3; // debord cadre vis à vis bord écran
int debordCadre=debord+3; // debord vis à vis du bord cadre
int hautCadre=30; // hauteur cadre saisie

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

char operation; // opération à effectuer

// — 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é du champ de saisie —–
// rectangle de largeur = taille et centré sur xo,yo

lcd.fillRect (0+debord,0+debord,lcd.getWidth()–1–debord,hautCadre+debord,jaune); // trace rectangle
lcd.drawRect (0+debord,0+debord,lcd.getWidth()–1–debord,hautCadre+debord,bleu); // trace rectangle
// —– 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

  } // fin for colonnes

} // fin for lignes

// message www.mon-club-elec.fr
lcd.drawText(debordCadre,60,« Touchpad Calculator »,1,rouge,blanc);
lcd.drawText(debordCadre,70,« by www.mon-club-elec.fr »,1,rouge,blanc);

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

      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);
    posX=lcd.drawChar(posXo,0+debordCadre+5,touches[ligneSelect–1][colonneSelect–1],2,bleu,jaune);

    //—- affiche la valeur numerique correspondante
    valeur=touches[ligneSelect–1][colonneSelect–1]–48; // transforme ASCII en valeur numérique

    if ((valeur>=0) && (valeur<=9)) { // si valeur touche entre 0 et 9

      // lcd.drawText(posXo,70,valeur,1,bleu,jaune);

      //—- affiche la valeur numerique entiere Saisie [indice]
      valeurSaisie[indice]=(valeurSaisie[indice]*10)+valeur; // x10 et ajoute unité

      //lcd.drawText(0,78,valeurSaisie[indice],1,bleu,jaune);

    } // fin si valeur touche entre 0 et 9
    else if (touches[ligneSelect–1][colonneSelect–1]==‘+’) operation=‘+’, indice=1; // mémorise operation et passe saisie 2ème valeur
    else if (touches[ligneSelect–1][colonneSelect–1]==‘-‘) operation=‘-‘, indice=1; // mémorise operation et passe saisie 2ème valeur
    else if (touches[ligneSelect–1][colonneSelect–1]==‘x’) operation=‘x’, indice=1; // mémorise operation et passe saisie 2ème valeur
    else if (touches[ligneSelect–1][colonneSelect–1]==‘/’) operation=‘/’, indice=1; // mémorise operation et passe saisie 2ème valeur
    else if (touches[ligneSelect–1][colonneSelect–1]==‘=’) { // si signe égal on fait l’opération

      if (operation==‘+’) resultat=valeurSaisie[0]+valeurSaisie[1];
      if (operation==‘-‘) resultat=valeurSaisie[0]–valeurSaisie[1];
      if (operation==‘x’) resultat=valeurSaisie[0]*valeurSaisie[1];
      if (operation==‘/’) resultat=valeurSaisie[0]/valeurSaisie[1];

      // affiche le resultat à la suite des nombres saisis
      // lcd.drawText(posX,55,resultat,2,jaune,noir);
      lcd.drawText(debordCadre,40,resultat,2,noir,blanc);

      //— réinitialisation pour calcul suivant
      indice=0; // RAZ indice
      valeurSaisie[0]=0; // RAZ valeur Saisie [0]
      valeurSaisie[1]=0; // RAZ valeur Saisie [1]

      posX=debordCadre; // réinitialise posX

    } // fin si signe égal

    else if (touches[ligneSelect–1][colonneSelect–1]==‘.’) { // si point on efface

       //lcd.drawText(0,55, »               « ,2,jaune,blanc); // efface saisie

      lcd.fillRect (0+debord,0+debord,lcd.getWidth()–1–debord,hautCadre+debord,jaune); // trace rectangle
      lcd.drawRect (0+debord,0+debord,lcd.getWidth()–1–debord,hautCadre+debord,bleu); // trace rectangle

       lcd.drawText(debordCadre,40, »               « ,2,noir,blanc);

        //— réinitialisation pour calcul suivant
      indice=0; // RAZ indice
      valeurSaisie[0]=0; // RAZ valeur Saisie [0]
      valeurSaisie[1]=0; // RAZ valeur Saisie [1]

      posX=debordCadre; // réinitialise posX
    }

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

      delay(300); // anti-rebond si un appui

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