Touches tactiles en Midi

Description

Hommage aux pianistes anonymes qui improvisaient les bandes sons des films muets, instrument intelligent, capricieux et difficile à cerner, entre classicisme et intelligence artificielle, le PIANOFICTILE utilise le son et la lumière pour intervenir sur l’espace qui l’entoure, créer des fragments fictionnels et poétiques. Ce piano hybride conçu par le Collectif Arbuste est augmenté d’un tableau de bord aux fonctions mystérieuses. Évocation des vieux pianos bastringues des westerns et du cinéma muet, il révèle des propriétés acoustiques bizarroïdes et inouïes, déclenche des sections de dialogues et autres ambiances, influe sur l’éclairage de l’espace.

Ce “générateur d’ambiances fictionnelles” est issu d’une création pour les 1 ans de la Médiathèque de La Ciotat. Instinctif, il a été conçu pour être laissé en libre service. Il peut également servir d’instrument de base pour des performances/concerts réalisées par les membres du collectif.

Matériaux

  • une carte Teensy 3.1
  • un Teensy 3.1 breakout, qui permet d'exploiter facilement toutes les “pins” de la carte Teensy. Ceci n'est pas obligatoire, mais certaines pins sont sous la carte et sont complexes à relier à des fils car en SMD, le breakout (qui peut s'acheter monté avec une teensy) règle ce problème en rendant accessibles toutes les pins de la carte.
  • fil de montage
  • pièces de cuivre, ou bandes d'adhésif conducteur (cuivre, aluminium,…), ou pièces métalliques
  • potentiomètres (10K)
  • interrupteurs momentanés ou switches
  • 12 résistances (par controleur construit) de 10K en SMD (montage sur surface) de format 1206 (de ce type: resistance 10K en 1206 ). celles ci sont un peu difficile à souder car très petites, mais restent avantageuses de par le gain de place qu'elles permettent.

Tutoriel

les cartes Teensy ( http://www.pjrc.com/teensy/index.html ) sont des petits microcontrôleurs (un peu comme arduino ) qui ont la particularité d'être programmable avec le même environnement qu'arduino, grâce à un logiciel additionnel: Teensyduino

Si Arduino est une solution très répandue (et efficace) dans de nombreux projets impliquant du MIDI pour communiquer avec un ordinateur ou des synthétiseurs, Teensy présente un avantage non négligeable en offrant la possibilité de transmettre le MIDI via l'USB ( et dans les deux sens: vers l'ordinateur / depuis l'ordinateur) , alors qu'une Arduino nécessite l'ajout d'une sortie MIDI en hardware (via la sortie Tx) et l'utilisation d'une interface MIDI to USB pour permettre de récupérer les données MIDI sur un ordinateur.

Dans le cas où l'on veut fabriquer un contrôleur MIDI USB, une carte Teensy s'avère donc une solution plus simple (et accessoirement plus petite et facilement intégrable dans un boitier)

L'autre particularité de Teensy, c'est d'offrir 12 entrées “touch”, qui permettent d'utiliser n'importe quel objet conducteur comme une touche tactile, qu'ici on utilisera pour envoyer une note MIDI.

Ce tutoriel documente la construction d'un Controleur Midi Usb avec:

- 12 touches tactiles qui envoient des notes MIDI. Petite précision: nous n'avons pas trouvé comment exploiter la pression/surface de contact comme une donnée utilisable musicalement. Cette donnée n'est pas documentée chez PJRC, qui produit les teensy.
- 8 entrées analogiques qui lisent des potentiomètres et envoient des Control Change (CC) MIDI
- 4 entrées digitales qui envoient des Control Change

1- DESIGN D'UN PCB: en utilisant Fritzing ( Fritzing ), j'ai conçu un petit circuit imprimé pour pouvoir disposer de petits borniers à vis pour connecter plus facilement les câbles qui partiront vers les touches tactiles, les potentiomètres et les footswitches que l'on compte utiliser.

le fichier du PCB que j'ai envoyé au fritzing fab (tout se fait depuis fritzing) est ici:Touchboard_1

(Le design ne respecte surement pas toutes les règles de design d'un circuit imprimé et est surement loin d'être parfait / optimisé, mais je suis musicien, pas ingénieur).

Le circuit vu dans Fritzing:

Le circuit une fois reçu, et monté:

2- MONTAGE DES COMPOSANTS SUR LA CARTE:
Commencer par les résistances smd de 10K: poser un peu de soudure sur un des plots carrés qui leurs sont destinés, placer la résistance et souder un de ses cotés sur le plot en appuyant doucement dessus, lorsqu'elle est placée, souder l'autre côté de la résistance.

Souder ensuite les borniers, et enfin la carte teensy (auparavant montée sur son Breakout).

Voilà la carte montée:
sur la photo ci-dessous, les 12 entrées pour les touches tactiles sont en haut. Sur la droite se trouvent les 4 entrées digitales, et en bas les borniers vers les 8 entrées analogiques. Pour les entrées digitales et analogiques: le 3.3V est marqué “+”, l'entrée est au centre du bornier marquée par son numéro, et la masse est marquée “gnd” et se trouve sur la droite.

3- LE CODE:

J'ai trouvé sur le site du brillant Yann Seznec un code qu'il a généreusement mis en ligne ici: http://www.yannseznec.com/works/teensy-usb-midi-controller-code/

ATTENTION: au moment où j'ai réalisé les contrôleurs, Teensyduino était compatible avec la version 1.05 de Arduino.

voilà ma version du code qui a été utilisée sur les contrôleurs (j'ai laissé des parties en commentaires) :

Dans le code ci dessous, les entrées touch numérotées de 1 à 12 envoient les notes 36 à 47 (vélocité 0 ou 127, soit note on et note off) (de Do à Si chromatiquement), toutes les données midi sont transmises sur le canal midi 1 (facilement modifiable dans le code), les entrées analogiques envoient des control changes qui varient entre 0 et 127 (CC 50 à 57), et les entrées digitales envoient des control changes (CC 10 à 13) qui auront soit une valeur de 0 soit une valeur de 127 (0 = off, 127 = on).

/* some code designed for using the Teensy 3 as a USB MIDI controller
v1.0, December 17 2013
by Yann Seznec www.yannseznec.com
modified by Matthieu Pernaud for teensy 3.1 and for different purposes:
 
use of all 12 touch pins to send midi notes.
use of all analog pins available.
use of digital pins to send notes.
 
remember to select MIDI as your USB Type in the Tools menu
 
this should also work with other Teensy boards, apart from the "touch" pins
 
things that are kind of dumb in this code:
- the touch threshold is hard coded (int touchThreshold)
- touch pins only send midi note on/off with no velocity change
- no system for sending touch pin as CC
- the CC assignments are sort of random, probably should have another array for them
*/
 
/* TOUCHPINS - send midi notes */
int const numTouchPins = 12; // number of pins to use as touchpins, sending note values
int touch[numTouchPins];
int touchon[numTouchPins];
int touchpin[] = {
  0,1,15,16,17,18,19,22,23,25,32,33}; // which digital pins to use as touch pins
  int touchpitch[] = {
  36,37,38,39,40,41,42,43,44,45,46,47}; // MIDI pitches
  int touchThreshold = 3200; 
  int touchMax = 4000; 
 
/*ANALOG PINS*/
int const numPins = 8; //  number of analog inputs 
int currentVal[numPins];
int newVal[numPins];
int analogPins[] = {  
A10,A11,A12,A13,A14,A15,A16,A17   // which analog pins to use 
};
int analogstartcc = 50; // MIDI CC number to start from.
 
int const numDigPins = 0; // number of digital pins to send note values
int currentDig[numDigPins];
int digitalpin[] = {
  2,3,4,5,6,7    // which digital pins to use for sending note values
};
int digitalpitch[] = {
  48,50,51,53,55,57}; // which midi notes to send from the digital pins selected above
int digInput[numDigPins];
 
int const numDigPinsCC = 4; // number of digital pins to send CC
int currentDigcc[numDigPinsCC];
int digitalpincc[] = {
   10,11,12,24 // which digital pins to use for sending CC
};
int digccstart = 10; // CC number to start from
 
int digInputcc[numDigPinsCC];
 
// the MIDI channel number to send messages on
const int channel = 1;
 
void setup() {
  pinMode(10, INPUT_PULLUP);
  pinMode(11, INPUT_PULLUP);
  pinMode(12, INPUT_PULLUP); 
  pinMode(24, INPUT_PULLUP);
  Serial.begin(38400);
}
 
void loop() {
  //  touch sending notes
  for (int i = 0; i < numTouchPins; i++) {
    touch[i] = touchRead(touchpin[i]); 
 
    if (touch[i] > touchThreshold && touchon[i] == 0) {
      usbMIDI.sendNoteOn(touchpitch[i], 100, channel);
      touchon[i] = 1;
    }
    if (touch[i] < touchThreshold && touchon[i] == 1) {
          usbMIDI.sendNoteOff(touchpitch[i], 100, channel);
          touchon[i] = 0;
    }
 
/*  touchpads
  for (int i = 0; i < numTouchPins; i++) {
    touch[i] = touchRead(touchpin[i]); 
 
    if (touch[i] > touchThreshold && touchon[i] == 0) {
usbMIDI.sendControlChange(i+25,map(touch[i], touchThreshold, touchMax, 0, 127),4);
      touchon[i] = 1;
    }
    if (touch[i] < touchThreshold && touchon[i] == 1) {
usbMIDI.sendControlChange(i+25,0,4);
      touchon[i] = 0;
    }
 
  }
  */
// digital pins sending notes
//  for (int i = 0; i < numDigPins; i++) {
//    if (digitalRead(digitalpin[i]) == 1 && currentDig[i] == 0) {
//      usbMIDI.sendNoteOff(digitalpitch[i], 100, channel); 
//      currentDig[i] = 1;
//    }  
//    if (digitalRead(digitalpin[i]) == 0  && currentDig[i] == 1) {
//      usbMIDI.sendNoteOn(digitalpitch[i], 100, channel);
//      currentDig[i] = 0;
//    }  
//  }
 
  //// digital pins sending CC
  for (int i = 0; i < numDigPinsCC; i++) {
    if (digitalRead(digitalpincc[i]) == 1 && currentDigcc[i] == 0) {
      usbMIDI.sendControlChange(i+digccstart, 127, channel); 
      currentDigcc[i] = 1;
    }  
    if (digitalRead(digitalpincc[i]) == 0  && currentDigcc[i] == 1) {
      usbMIDI.sendControlChange(i+digccstart, 0, channel);
      currentDigcc[i] = 0;
    }  
  }
 
//// analog pins
  for (int i = 0; i < numPins; i++) {
    newVal[i] = analogRead(analogPins[i]);
    if (abs(newVal[i] - currentVal[i])>3) 
    {
      usbMIDI.sendControlChange(i+analogstartcc, newVal[i]>>3, channel); 
      currentVal[i] = newVal[i];
    }  
  }
 
  // i think if you remove these last two lines everything breaks and things are sad and people cry
  while (usbMIDI.read()); // read and discard any incoming MIDI messages
  delay(5); 
}
}

4-CABLAGE:

Pour cabler des potentiomètres sur les entrées analogiques:

connecter le 3.3V (“+” sur la carte) sur la broche de droite du potentiomètre, l'entrée capteur “AX” (où X est le numéro de l'entrée analogique de la teensy) à la broche du milieu du potentiomètre, et la masse (“GND” sur la carte) sur la broche de gauche du potentiomètre.

Si vous comptez connecter un capteur de distance (par exemple) qui nécessite une alimentation, ne soudez pas de résistance SMD de 10K sur l'entrée correspondante et prenez en compte le fait que la carte Teensy ne produit que du 3.3V (pas du 5V comme une arduino Uno, par exemple)

Pour cabler des switches sur les entrées digitales:

connecter le “+” à une des broches du switch, et connecter l'autre broche à l'entrée du milieu sur la carte.

Pour cabler les entrées “touch”: simplement connecter la pièce métallique conductrice à un fil qui va à une des entrées “touch” de la carte. Pour notre part, nous avons dessiné un clavier stylisé qui a été découpé et fraisé dans de la plaque en cuivre au Fablab de Marseille.

TEST:

voilà un patch Pure Data pour tester la carte (avec le code ci dessus uploadé):

Photos