Utilisation d'un Resistive Touch Screen à 4 fils

Salut à tous - ça y'est j'ai reçu mes gadgets chinois pour tenter la connexion de la nappe de mon resistive touch screen.

1.resistive.png

Mon challenge était que le connecteur standard


n'est pas soudable simplement (j'ai essayé ainsi que @al1fch) et qu'il fallait donc trouver un connecteur.

@al1fch m'avait aidé en indiquant qu'il fallait chercher une connectique FFC/FPC (flexible printed circuit)

J'avais donc parcouru eBay et autres et je m'étais arrêté sur 2 possibilités:

Des FPC FFC 1mm 1.0mm Pitch 4 Pin Dual Contact Straight Ribbon

thisone.png

et des Connecteur-Plat

En pratique, les seconds ne sont pas utilisables par le commun des mortels :slight_smile: il faudrait faire un circuit avec des pistes fines pour souder le composant à plat dessus.... J'ai essayé mais c'est trop délicat et j'ai laissé tombé l'idée, les composants iront dormir au fond du tiroir.

Les premiers sont cependant tout à fait "bricolables". ils présentent 4 pins verticales organisées sur 2 rangs - donc pas adaptées à une breadboard mais qu'on peut cependant forcer dans les trous d'une plaque d'essai à Pastilles cuivrées standard

Et avec 4 petits fils fins récupérés dans du fil de téléphone et un header on peut faire (à l'arrache ici - j'avais pas une panne fine sur mon fer à souder et la flemme de changer ... désolé pour les puristes) quelques soudures pour avoir quelque chose qui se branche dans une breadboard.

3.avecfils.png

Bon une fois le bricolage effectué, et le petit câble souple enfiché, comment les utilise-t-on ?


Le principe de ces écrans résistifs est relativement simple. Nous avons un écran transparent avec quatre fils sortant pour son interface. Bien que transparent, il se compose d'un support en plastic et de 2 couches résistives parallèles l’une sur l’autre, séparées par un isolant. Lorsque l'utilisateur touche l'écran tactile, les deux couches résistives font contact en un point et un réseau résistif diviseur de tension est établi.

Voici la vue illustrée de la façon dont le réseau résistif est établi.

4.réseauResistif.png

Il faut donc identifier les 2 fils qui indiquent l’axe des X (X1 et X2) et les deux autres l’axe des Y (Y1 et Y2). Pour savoir quelles sont les pins X1, X2, Y1 et Y2 il faut regarder attentivement la nappe arrivant sur l'écran

5.pistes.png

et suivre les pistes. En posant l'écran sur un support contrasté (ici un post-it qui a pile la taille) on voit où vont les fils (2 d'un côté de l'écran et 2 de l'autre)

En configurant de manière adaptée les pins et en mesurant une tension résultante, ils est possible d'obtenir en 2 mesures une information (x,y) qui donnera la position relative du point touché sur le support.

Pour bien stabiliser la lecture, j'ai mis des pull-down sur les 4 pins de l'écran avec une résistance de 10kΩ.

donc la connexion par exemple pour X1 ressemble à cela

X1 ------- A1
        |
        |
    10kΩ ------ GND

Sparkfun a un petit PDF en anglais (et plein d'autres sur le web) expliquant comment tout cela fonctionne donc je ne vais pas rentrer dans les détails,

En pratique on met X1 à 5V par exemple et X2 à GND, on configure Y2 en haute impédance et on mesure sur ce que l'on voit sur Y1 pour obtenir x.

On fait de même dans l'autre sens pour lire sur X1 la valeur de y

Donc une fois tout branché - vérifiez bien où vous avez soudé vos pins - il ne reste plus qu'à écrire un petit bout de code:

// explication: http://forum.arduino.cc/index.php?topic=591898.new#new
// J-M-L pour le forum Arduino

// les pins
const byte X1 = A1;
const byte X2 = A0;
const byte Y2 = A3;
const byte Y1 = A2;

// calibrage obtenu en lisant X et Y
const int Xmin = 57;
const int Xmax = 831;
const int Ymin = 90;
const int Ymax = 807;

// définissez la résolution voulue en sortie (restez raisonables :) )
// la zone sensible de mon écran fait 70mm x 54mm, je décide d'avoir 2 points par mm
// on pourrait aller plus loin, ça dépend de la qualité et résolution de la résistance de votre écran résistif
const int Xresolution = 140;
const int Yresolution = 108;


bool lireXY(int &X, int &Y)
{

  // Y2 en Tristate
  pinMode(Y1, INPUT);
  pinMode(Y2, INPUT);
  digitalWrite(Y2, LOW);

  // diviseur de tension entre X1(+5V) and X2(GND)
  pinMode(X1, OUTPUT); digitalWrite(X1, HIGH);
  pinMode(X2, OUTPUT); digitalWrite(X2, LOW);

  // Lecture du X
  int x = analogRead(Y1);
  // pour calibrer et trouver Xmin et Xmax, enlever le commentaire ci dessous
  // et faire bouger une pointe vers la gauche (Xmin) et vers la droite (Xmax) de l'écran résistif
  // Serial.print(F("x=")); Serial.print(x);

  // X2 en Tristate
  pinMode(X1, INPUT);
  pinMode(X2, INPUT);
  digitalWrite(X2, LOW);

  // diviseur de tension entre Y1(+5V) and Y2(GND)
  pinMode(Y1, OUTPUT);
  digitalWrite(Y1, HIGH);
  pinMode(Y2, OUTPUT);
  digitalWrite(Y2, LOW);

  // lecture du Y
  int y = analogRead(X1);
  // pour calibrer et trouver Ymin et Ymax, enlever le commentaire ci dessous
  // et faire bouger une pointe vers le haut (Ymin) et vers le bas (Ymax) de l'écran résistif
  //  Serial.print(F("\ty=")); Serial.println(y);

  // si on n'est pas dans les bornes, c'est qu'on appuie pas sur l'écran
  if ((x >= Xmin) && (y >= Ymin) && (x <= Xmax) && (y <= Ymax)) {
    // sinon on fait une homotétie pour amener la mesure entre X:[0, Xresolution] et Y:[0, Yresolution]
    X = constrain(map(x, Xmin, Xmax, 0, Xresolution), 0, Xresolution);
    Y = constrain(map(y, Ymin, Ymax, 0, Yresolution), 0, Xresolution);
    return true;
  }
  return false;
}


void setup()
{
  Serial.begin(115200);
}


void loop()
{
  static int oldX = -1, oldY = -1;
  int X, Y;

  if (lireXY(X, Y)) { // retourne true si l'écran est appuyé, avec les coordonnées fournies dans X et Y
    if ((X != oldX) || (Y != oldY)) { // imprime les nouvelles coordonnée si elles ont changé
      Serial.print(F("X=")); Serial.print(X);
      Serial.print(F("\tY=")); Serial.println(Y);
      oldX = X;
      oldY = Y;
    }
  }

}

bien sûr la valeur qu'on va lire (par un analogRead) est relative et dépend de votre écran (taille, résistivité du film). Donc il va falloir calibrer.

Dans le code ci-dessus le calibrage revient à trouver quelles sont les valeurs que analogRead() retourne quand vous êtes aux min et max des axes.

il y a deux lignes à dé-commenter pour afficher la valeur brute de analogRead(), faites le, charger le programme et appuyez doucement avec un stylet sur l'écran. allez tout à gauche de la zone sensitive (on voit une légère bordure sur le plastique), vous aurez la valeur de Xmin. allez tout à droite et vous aurez la valeur de Xmax. Allez tout en haut et vous aurez la valeur de Ymin et tout en bas pour Ymax.

Notez ces valeurs et mettez les à jour dans le code, voilà mes valeurs

// calibrage obtenu en lisant X et Y
const int Xmin = 57;
const int Xmax = 831;
const int Ymin = 90;
const int Ymax = 807;

Enfin le code vous permet de définir quel coordonnées max vous voulez obtenir. En haut à gauche vous serez en (0,0), et en définissant Xresolution et Yresolution vous donnez les coordonnées du point en bas à droite de la zone sensitive.

Voilà, avec ce code la fonction lireXY() retourne vrai si l'écran est appuyé avec ses paramètres mis à jour.

PS/ J'ai trouvé plus tard - pour ceux qui ne veulent pas bricoler et veulent débourser 3,43 euros, qu'il y a un PCB utilisant le connecteur plat chez Adafruit (Référence Digi-Key 1528-1063-ND)

1 Like

Bon boulot !

joli tuto :slight_smile: