Maurin Donneaud

Designer d’interaction @ www.eTextile.org - Paris

Tapis/tutoriel

Le principe mis en œuvre dans ce tapis est une adaptation du textileXY qui permet de localiser précisément un point de contact sur une toile tendue. La technique employée pour le textileXY nécessite cependant un cadre de maintien. Dans le cas du tapis, le travail réalisé en collaboration avec la SARL Malterre, a consisté à développer une structure textile originale pour supprimer ce cadre rigide.

Ce projet est aussi une évolution du projet Keyboard qui permet de localiser précisément plusieurs points d’appuis sur un tapis clavier. A l’inverse de ce dernier, le tapis capteur est une solution beaucoup plus simple à réaliser, notamment car il ne nécessite pas plus de trois connections entre le tapis et la carte électronique embarquée. Cette simplification a cependant contraint la détection à seulement deux points de contact qui correspondent aux mouvements des deux pieds d’une personne qui se déplace sur le tapis.

Composée de deux couches, le textile capteur qui se glisse sous un tapis traditionnel, fonctionne à la fois comme un interrupteur mais aussi comme un potentiomètre. La fonction d’interrupteur est assurée par des bandes isolantes qui permettent de maintenir écartées les fibres conductrices intégrées dans la couche supérieure du capteur textile (N°1, schéma). Ces bandes, réalisées en bouclette donnent au matériau la résilience nécessaire pour revenir en forme suite à un écrasement du pied.

La fonction de potentiomètre qui permet de localiser la position des deux pieds sur le tapis est assurée par l’intégration d’une bande résistive sur la lisière du textile supérieur (N°2, schéma). Cette bande résistive fait la liaison électrique entre chacune des pistes conductrices du textile. C’est cette connections qui constitue le point le plus délicat de la mise en œuvre de ce capteur. Une solution efficace consiste à utiliser une encre résistive pour enduire la lisère du textile. Cependant cette technique doit être réalisée avec précaution pour que l’encre soit déposée de façon régulière et homogène. La couche inférieure du capteur est un textile entièrement conductrice (N°3, schéma).

schéma technique de la structure technique du textile

PNG - 32.3 ko

La carte électronique

Pour détecter les mouvements des pieds et déclencher les sons correspondants, le dispositif comporte une carte électronique capable de lire des fichiers sons (MP3) pour les diffuser sur des enceintes pré-amplifiées disposées à proximité du tapis. Pour fonctionner, ce dispositif autonome nécessite cependant une alimentation électrique.

http://snootlab.com/pjrc-teensy/517-teensy-31-usb-fr.html
http://snootlab.com/pjrc-teensy/714-adaptateur-audio-pour-teensy-30-et-31-fr.html

La connectique

La liaison entre le textile capteur et la carte électronique...

Tapis/Arduino/firmware

  1. /*
  2.  Code Arduino pour le projet "TapisSon"
  3.  un tapis interactif et musical
  4.  bidirectional potentiometer
  5.  this sketch sense the two resistor
  6.  
  7.  VccGndPinA
  8.  |
  9.  |
  10.  - R1
  11.  |
  12.  |
  13.  |-----| textile |---------> sensorPin
  14.  |                   |
  15.  |                   |
  16.  - R2                - R3
  17.  |                   |
  18.  |                   |
  19.  VccGndPinB         GND
  20.  
  21.  R1 is variable
  22.  R2 is variable
  23.  R3 is constant 10K
  24.  
  25.  */
  26. /////////////////////// variables
  27. const unsigned int VccGndPinA = 5;         // use as Vcc or Gnd
  28. const unsigned int VccGndPinB = 10;        // use as Vcc or gnd
  29. const unsigned int sensorPin = A0;        // select the input pin for both side of the potentiometer sensing
  30. int rowSensorVal = 0;
  31. unsigned int DELAY = 50;
  32. boolean DEBUG = true;
  33. /////////////////////// initialisation
  34. void setup(){
  35.   pinMode(VccGndPinA, OUTPUT);
  36.   pinMode(VccGndPinB, OUTPUT);
  37.   if(DEBUG) Serial.begin(9600), Serial.println("boot");
  38. }
  39. /////////////////////// boucle principale
  40. void loop(){
  41.  
  42.   ////////////////////////////////////////////////////// time 0
  43.   digitalWrite(VccGndPinA, HIGH); // GND
  44.   digitalWrite(VccGndPinB, LOW);  // GND
  45.   delay(DELAY);
  46.   rowSensorVal = analogRead(sensorPin);
  47.   if(DEBUG) Serial.print(rowSensorVal), Serial.print(" ");
  48.   if(!DEBUG) transmit2byteA(rowSensorVal);
  49.  
  50.   ////////////////////////////////////////////////////// time 1
  51.   digitalWrite(VccGndPinA, LOW); // GND
  52.   digitalWrite(VccGndPinB, HIGH);  // GND
  53.   delay(DELAY);
  54.  
  55.   rowSensorVal = analogRead(sensorPin);
  56.   if(DEBUG) Serial.println(rowSensorVal);
  57.   if(!DEBUG) transmit2byteB(rowSensorVal);
  58.   delay(DELAY);
  59. }
  60. ////////////////// fonctions de communication série (Arduino -> PC)
  61. void transmit2byteA(int data){
  62.   byte msbA, lsbA;
  63.   // octet 1 for X ; MSB for X (More Signifiant Bits)
  64.   // 00000xxx  Value (after being shifted 5 times)
  65.   // ||
  66.   // ||--------> MSB
  67.   // |---------> X
  68.   msbA =  data >> 5 ;                 // Division by 32, save the 5 Msb bits
  69.   Serial.write(msbA);                  // Send X MSB
  70.   // octet 0 for X ; LSB for X (Less Signifiant Bits)
  71.   // xxxxxxxx       value
  72.   // 00011111     & mask (31)
  73.   // 01000000     + flag
  74.   // 010xxxxx     = result for
  75.   // 01000000     + 64     for LSB flag
  76.   // first bit is 0 for X flag
  77.   lsbA =  data & 31 ;                 // save the 5 lsb bits
  78.   lsbA = lsbA + 64 ;                   // set second bit to 1 for lsb marker
  79.   Serial.write(lsbA);                  // Send X LSB
  80. }
  81. void transmit2byteB(int data){
  82.   byte msbB, lsbB;
  83.   // octet 1 for Y ; MSB for Y (More Significant Bits)
  84.   // 10000xxx  Value (after being shifted 5 times)
  85.   // ||
  86.   // ||--------> MSB
  87.   // |---------> 1=>Y
  88.   msbB = data >> 5 ;                  // Division by 32, save the 5 Msb bits
  89.   msbB = msbB + 128 ;                  // add a bit for Y
  90.   Serial.write(msbB);                  // Send Y MSB
  91.   // octet 0 for Y ; LSB for Y (Less Significant Bits)
  92.   // xxxxxxxx       value
  93.   // 00011111     & mask
  94.   // 000xxxxx     = result
  95.   // 01000000     + 64     for LSB flag
  96.   // 10000000     + 128    for Y flag
  97.   lsbB = data & 31 ;                  // save the 5 lsb bits
  98.   lsbB = lsbB + 64 ;                   // set second bit to 1 for lsb marker
  99.   lsbB = lsbB + 128 ;                  // add a bit for Y
  100.   Serial.write(lsbB);                  // Send Y LSB
  101. }
Télécharger
Forum sur abonnement

Pour participer à ce forum, vous devez vous enregistrer au préalable. Merci d'indiquer ci-dessous l'identifiant personnel qui vous a été fourni. Si vous n'êtes pas enregistré, vous devez vous inscrire.

Connexion | s'inscrire | mot de passe oublié ?