Contrôleur de Souffle Arduino Abordable avec Intégration USB-MIDI

Composants et fournitures

Arduino Micro	×	1	Vous pourriez probablement réduire le coût avec un clone, mais je recommande l'original. Seule la Micro (ATmega32U4) fonctionnera grâce à ses capacités USB natives.
Plaque d'essai sans soudure (demi-taille)	×	1
Capteur de Pression MPS20N0040D-D	×	1	Très bon marché et facile à trouver.
Amplificateur Opérationnel LM358-N	×	1	Nous utiliserons le populaire amplificateur opérationnel LM358 pour amplifier le signal du capteur.
Résistance 1M ohm	×	2
Kit de fils de connexion 22 AWG	×	1	Vous n'avez pas besoin d'un kit complet, juste quelques cm de fil rigide.
Aspirateur Nasal pour Bébé	×	1	Oui, vous avez bien lu. Nous utiliserons l'embout buccal côté parent et l'aspirateur côté bébé. Il existe des dizaines d'aspirateurs manuels du même type (par exemple Physiomer, Chicco Physioclean, etc.). Choisissez le type d'embout qui vous semble le plus confortable.
Tuyau d'aquarium 5mm	×	1	Optionnel, si le tuyau de l'aspirateur n'est pas assez long. Un tuyau d'aquarium standard fera l'affaire.
Connecteur en T pour tuyau d'air	×	1	Ce connecteur OEM chinois spécifique se trouve facilement dans les magasins d'aquariophilie sous différents noms. Il s'adapte directement sur le capteur.

Outils nécessaires

Pince à dénuder et couper, 32-20 AWG / 0,05-0,5mm²

Applications et services en ligne

Arduino IDE

À propos de ce projet

Introduction

Dans ce projet, nous allons construire un contrôleur de souffle USB MIDI plug-and-play simple. Il est conçu avec des composants faciles à trouver et bon marché pour que le coût total reste abordable, bien en dessous des équivalents commerciaux. C'est la version de base qui n'utilise que le capteur de pression d'air, mais le plan est de l'améliorer pour inclure un capteur de morsure et un capteur de hochement/inclinaison à l'avenir.

Le projet suppose quelques connaissances de base en électronique et Arduino, mais même un débutant peut le construire car il n'y a pas de soudure nécessaire. Bien sûr, les utilisateurs plus avancés peuvent tout souder sur une plaque perma-proto. Je ne couvre pas l'installation de l'IDE/bibliothèques et les instructions pour téléverser le code car il existe d'excellents tutoriels sur Internet.

Le suréchantillonnage (oversampling) est utilisé pour lisser l'entrée du capteur avec d'excellents résultats. Vous pouvez également ajuster la plage à votre goût et même définir des courbes personnalisées pour ajuster le comportement du contrôleur.

Puisque le capteur peut mesurer la pression négative aussi, il y a un second flux de messages de contrôleur qui est émis quand vous aspirez l'air au lieu de souffler. Les deux types de messages peuvent être définis par l'utilisateur. Par exemple, vous pouvez régler le souffle sur « pitch bend up » et l'aspiration sur « pitch bend down ». Par défaut, les deux sont réglés sur le contrôleur n°2.

Étapes de construction

1. Insérez l'Arduino sur la plaque d'essai comme montré sur la photo/schéma.

2. Insérez le capteur et l'amplificateur opérationnel à leurs positions respectives, remarquez l'orientation basée sur les petites encoches sur leurs côtés.
3. Insérez les résistances après avoir coupé leurs pattes à la longueur appropriée.
4. Coupez/dénudez les fils rigides et placez-les à leurs positions respectives. J'ai utilisé du rouge pour 5V, noir pour la masse et jaune pour le signal pour faciliter la compréhension, mais vous pouvez bien sûr utiliser ce que vous avez sous la main.
5. Connectez l'embout buccal, le tuyau, le connecteur en T et l'aspirateur comme montré sur la photo. Vous devrez couper un morceau de tuyau pour l'« échappement ».

6. Appuyez sur le connecteur en T pour qu'il s'adapte sur le capteur. Il doit rester en place.

7. Installez l'Arduino IDE et installez les deux bibliothèques nécessaires (Oversampling et USB-MIDI) depuis Outils → Gérer les bibliothèques. Connectez l'Arduino avec un câble USB à votre ordinateur. Téléversez le code joint.
8. Vous devriez être prêt, l'Arduino devrait maintenant apparaître comme un périphérique MIDI dans votre DAW/Logiciel de musique. Activez-le et routez-le avec votre clavier vers un plug-in qui prend en charge le contrôleur de souffle.

Informations avancées

Un inconvénient physique de cette conception est la salive qui coulera inévitablement dans le tube et peut provoquer des fluctuations notables du flux d'air. Le connecteur en T est utilisé pour résoudre ce problème en acheminant la salive vers le tube d'« échappement ». Pour minimiser la salive piégée dans le tube, assurez-vous qu'il y a une pente continue de l'embout buccal au connecteur en T en ajustant la longueur du tuyau. Si le tube pend sous le niveau du connecteur en T, la saliva sera piégée à son point le plus bas causant des fluctuations. La partie côté bébé de l'aspirateur y compris son filtre est attachée à l'échappement pour minimiser le goutte-à-goutte ainsi que le bruit et augmenter le flux d'air vers le capteur.

Dans le code, il y a des valeurs que vous pouvez ajuster à votre goût, y compris des courbes personnalisées. Les commentaires décrivent comment faire. Si vous trouvez difficile d'atteindre le point 127, diminuez la plage maximale, ou si c'est trop facile, augmentez-la. Chaque fois que vous changez des valeurs, vous devrez re-téléverser le code.

Les premières lectures après le démarrage de l'Arduino sont moyennées pour calibrer la position de repos. Ne soufflez pas dans le tube pendant la connexion/réinitialisation de l'appareil.

Vous pouvez changer le nom du périphérique MIDI en éditant le fichier boards.txt (des informations sur la façon de faire cela pour chaque plateforme sont disponibles sur Internet).

Code

Code du contrôleur de souffle (Arduino)

/* Contrôleur de Souffle */
// Bibliothèques utilisées - les installer depuis Outils → Gérer les bibliothèques
#include <Oversampling.h>
#include <USB-MIDI.h>

// Mode debug (décommenter pour activer)
//#define DEBUG 1

// Création de l'interface USB MIDI
USBMIDI_CREATE_DEFAULT_INSTANCE();

// Initialisation du suréchantillonnage
Oversampling adc(10, 13, 6);

// ***************** Configuration Utilisateur *****************
// Les valeurs se terminant par 1 correspondent au souffle, celles se terminant par 2 à l'aspiration
// Configuration des broches
const int sensorPin1 = A0; // sélectionner la broche d'entrée Arduino pour la sortie Capteur/AmpliOp

// Calibrage de la plage. Ajustez manuellement pour pouvoir atteindre le maximum mais pas trop facilement.
int sensorRange1 = 800;
int sensorRange2 = 800;

// Numéro de contrôleur de sortie. Sélectionnez dans le tableau ci-dessous
// 0-127 : messages de contrôle réguliers
// 128 : aftertouch monophonique
// 129 : Pitch Bend Up
// 130 : Pitch Bend Down
int controllerNumber1 = 2; // Contrôleur envoyé quand on souffle
int controllerNumber2 = 2; // Contrôleur envoyé quand on aspire

// Canaux de contrôleur de sortie
int controllerChannel1 = 1;
int controllerChannel2 = 1;

// Seuils de sécurité pour les valeurs les plus basses et les plus hautes pour éviter les fluctuations au repos ou au max.
// Si plusieurs messages sont envoyés au repos, augmentez lowThreshold.
// Si plusieurs messages sont envoyés au max, augmentez highThreshold.
const int lowThreshold1 = 5;
const int lowThreshold2 = 5;
const int highThreshold1 = 0;
const int highThreshold2 = 0;

// Définition de la courbe. Les tableaux peuvent avoir n'importe quelle longueur égale ou supérieure à 2. Les valeurs peuvent être 0-127. Les tableaux doivent avoir le même nombre d'éléments et les tableaux "in" doivent être dans l'ordre croissant.
// Les conversions sont faites au niveau des lectures pour minimiser la perte de définition.
int in1[] = {0, 127};
int out1[] = {0, 127};
int in2[] = {0, 127};
int out2[] = {0, 127};

// Exemples de courbes (modifier le numéro de capteur en conséquence)
// Douce
//int in1[] = {0, 6,24,78,127};
//int out1[] = {0,32,64,96,127};
// Plage réduite
//int in1[] = {50, 100};
//int out1[] = {50, 100};

// Cycle de rafraîchissement (millisecondes). Des valeurs plus basses signifient plus de messages envoyés pendant le fonctionnement.
int refreshCycle = 0;

// ***************** Implémentation *****************
// Ne pas modifier à partir de ce point si vous n'avez pas l'intention de modifier le fonctionnement du capteur.

// Valeurs internes des capteurs
int sensorValue1 = 0;
int sensorValue2 = 0;

// Valeurs minimales des capteurs
int sensorMin1;
int sensorMin2;

// Valeurs de contrôleur de sortie
int controllerValue1 = 0;
int controllerValue2 = 0;

// Valeurs du cycle précédent utilisées pour éviter la répétition de messages identiques
int previousControllerValue1 = 0;
int previousControllerValue2 = 0;

// Variables d'initialisation de conversion de plage
int outputRange1;
int outputRange2;
int sensorLow1;
int sensorLow2;
int sensorHigh1;
int sensorHigh2;

void setup() {
  MIDI.begin(1);
  #ifdef DEBUG
  Serial.begin(115200); // Uniquement pour le mode debug
  #endif

  // Calibrer le point de repos du capteur en moyennant les 10 premières valeurs. N'utilisez pas le capteur pendant le démarrage.
  sensorMin1 = adc.read(sensorPin1);
  sensorMin2 = 0;

  // Déterminer les plages de sortie pour les contrôleurs choisis
  outputRange1 = outputRange(controllerNumber1);
  outputRange2 = outputRange(controllerNumber2);
}

void loop() {
  // lire la valeur du capteur :
  sensorValue1 = adc.read(sensorPin1);
  // Souffler de l'air
  sensorValue2 = sensorMin1 - sensorValue1; // Aspirer de l'air

  // Stocker les valeurs précédentes
  previousControllerValue1 = controllerValue1;
  previousControllerValue2 = controllerValue2;

  // Limites de plage utilisables pour le capteur haut/bas
  sensorLow1 = sensorMin1 + lowThreshold1;
  sensorLow2 = sensorMin2 + lowThreshold2;
  sensorHigh1 = sensorLow1 + sensorRange1 - highThreshold1;
  sensorHigh2 = min(sensorMin1, sensorRange2) - highThreshold2;

  // Convertir les valeurs internes en plage de sortie (0..127 pour contrôleurs/aftertouch, 0..+/-8191 pour Pitchbend Up/Down) en utilisant les courbes définies dans les tableaux "in" et "out".
  controllerValue1 = map(mapToCurve(constrain(sensorValue1, sensorLow1, sensorHigh1), sensorLow1, sensorHigh1, in1, out1, sizeof(in1)/sizeof(int)), sensorLow1, sensorHigh1, 0, outputRange1);
  controllerValue2 = map(mapToCurve(constrain(sensorValue2, sensorLow2, sensorHigh2), sensorLow2, sensorHigh2, in2, out2, sizeof(in2)/sizeof(int)), sensorLow2, sensorHigh2, 0, outputRange2);

  // Envoyer les messages MIDI
  if (controllerValue1 != previousControllerValue1) sendSensorOutput(controllerNumber1, controllerValue1, controllerChannel1);
  if (controllerValue2 != previousControllerValue2) sendSensorOutput(controllerNumber2, controllerValue2, controllerChannel2);

  // Debug
  #ifdef DEBUG
  // Valeurs capteur (entrée) (décommenter pour debug)
  // Serial.print(sensorValue1);
  // Serial.print(",");
  // Serial.print(sensorValue2);
  // Serial.print(",");
  // Valeurs contrôleur (sortie)
  Serial.print(controllerValue1);
  Serial.print(",");
  Serial.println(controllerValue2);
  #endif

  // arrêter le programme pour  millisecondes :
  delay(refreshCycle);
}

// Fonction utilisée pour envoyer les messages MIDI selon le numéro de contrôleur
void sendSensorOutput(int number, int value, int channel) {
  if (number < 128) MIDI.sendControlChange(number, value, channel);
  else if (number == 128) MIDI.sendAfterTouch(value, channel);
  else if (number == 129) MIDI.sendPitchBend(value, channel);
  else if (number == 130) MIDI.sendPitchBend(-value, channel);
}

// Fonction utilisée pour déterminer la plage d'un contrôleur spécifique. C'est dû au fait que pitch bend a une plage plus grande que les contrôleurs réguliers.
int outputRange(int number) {
  if (number > 128) return 8191;
  else return 127;
}

// Fonction multiMap modifiée utilisée pour créer des courbes. Originale par Rob Tillaart.
int mapToCurve(int val, int sensorLow, int sensorHigh, int* _in, int* _out, uint8_t size) {
  // s'assurer que la valeur est dans la plage
  // val = constrain(val, _in[0], _in[size-1]);
  if (val <= map(_in[0], 0, 127, sensorLow, sensorHigh)) return map(_out[0], 0, 127, sensorLow, sensorHigh);
  if (val >= map(_in[size-1], 0, 127, sensorLow, sensorHigh)) return map(_out[size-1], 0, 127, sensorLow, sensorHigh);

  // chercher le bon intervalle
  uint8_t pos = 1; // _in[0] déjà testé
  while(val > map(_in[pos], 0, 127, sensorLow, sensorHigh)) pos++;

  // ajuster la plage de ..127 à la plage du capteur
  int inPos = map(_in[pos], 0, 127, sensorLow, sensorHigh);
  int outPos = map(_out[pos], 0, 127, sensorLow, sensorHigh);
  int inPrv = map(_in[pos-1], 0, 127, sensorLow, sensorHigh);
  int outPrv = map(_out[pos-1], 0, 127, sensorLow, sensorHigh);

  // ceci gère tous les "points" exacts dans le tableau _in
  if (val == inPos) return outPos;

  // interpoler dans le bon segment pour le reste
  return ((long)val - (long)inPrv) * ((long)outPos - (long)outPrv) / ((long)inPos - (long)inPrv) + (long)outPrv;
}

Schémas

Schéma Fritzing

Schéma CircuitLab