fbpixel
Créer un Contrôleur MIDI avec Arduino

Créer un Contrôleur MIDI avec Arduino

Dans ce projet, nous allons fabriquer un boitier MIDI afin de tester les instruments du synthétiseur CoolSoft. et jouer quelques notes. Nous allons utiliser trois capteurs nous permettant de modifier les messages MIDI. Libre à vous de rajouter des éléments afin d’obtenir un contrôleur MIDI plus complet.

Prérequis: Créer une interface MIDI avec Arduino

Materiel

  • Arduino UNO
  • potentiomètre
  • encodeur rotatif
  • clavier 4×4 analogique

Fonctionnalités

Afin de tester la communication MIDI ainsi que le synthétiseur. Nous allons définir quelques fonctionnalités simples:

  • A l’aide du clavier nous allons envoyer des notes de musique
  • Le potentiomètre permet d’ajuster la vitesse de la note
  • Et l’encodeur va modifier l’instrument synthétisé

N.B.:Nous avons choisi un clavier analogique pour ce projet pour sa facilité de câblage afin de tester rapidement le synthétiseur. L’inconvénient est qu’on ne peut appuyer que sur une seule touche à la fois. Pour un contrôleur MIDI plus efficace, vous pouvez opter pour un clavier numérique ou encore des boutons d’arcade afin d’avoir un retour sur les notes jouées.

Schéma

N.B.: Pour faciliter la lecture, nous avons retiré l’afficheur 7-segment. Vous pouvez retrouver la connexion dans ce tutoriel.

Description du code

Dans un premier temps, nous allons définir des fonctions afin de gérer chacun des capteurs.

Pour le clavier 4×4, nous affectons à chaque touches un identifiant qui correspondra à une notes. Nous créons une fonction qui retourne l’identifiant lorsqu’une touche est pressée.

const int valThresh[nbABtn] = {1000, 900, 820, 750, 660, 620, 585, 540, 500, 475, 455, 425, 370, 300, 260, 200};
const int pitches[nbABtn] = {50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80 }
int getABtn() { /* function getABtn */  //// Read button states from keypad  int val = analogRead(abtnPin);  if (val <= 200) {    return 0;  } else {    for (int i = 0; i < 16; i++) {      if (val > valThresh[i]) {        delay(100);        return i + 1;      }    }  } }

Nous définissons une fonction readPot qui va modifier la valeur de vitesse velocity en fonction de la valeur du potentiomètre velVal.

void readPot(){
  velVal = map(int(analogRead(potPin) / 10) * 10, 0, 1023, 0, 127);
  if (oldVel != velVal) {
    //Serial.println(velVal);
    velocity = velVal;
  }
  oldVel = velVal;
}

La fonction qui gère l’encodeur, quant à elle, va nous permettre de modifier l’instrument de musique (identifiant rotVal entre 0 et 127).

void readRotary( ) { /* function readRotary */
  ////Test routine for Rotary
  // gestion position
  clkState = digitalRead(clkPin);
  if ((clkLast == LOW) && (clkState == HIGH)) {//rotary moving
    if (digitalRead(dtPin) == HIGH) {
      rotVal = rotVal - 1;
      if ( rotVal < 0 ) {
        rotVal = 0;
      }
    }
    else {
      rotVal++;
      if ( rotVal > 127 ) {
        rotVal = 127;
      }
    }
    MIDImessage(prgmChg, rotVal, 0);
    number = rotVal;
    for (int i = 0; i < NUM_OF_DIGITS; i++)
    {
      digit_data[i] = number % 10;
      number /= 10;
    }
    delay(200);

  }
  clkLast = clkState;

  //gestion bouton
  swState = digitalRead(swPin);
  if (swState == LOW && swLast == HIGH) {
    delay(100);//debounce
  }
  swLast = swState;
}

Une fois la modification de l’instrument prise en compte, nous affichons sa valeur sur le module 7 Segment.

void Display(int id, unsigned char num)
{
  digitalWrite(latch, LOW);
  shiftOut(data, cs, MSBFIRST, table[num]);
  digitalWrite(latch, HIGH);
  for (int j = 0; j < NUM_OF_DIGITS; j++) digitalWrite(dPins[j], LOW);
  digitalWrite(dPins[id], HIGH);
}

void updateDigits() {
  for (int j = 0; j < NUM_OF_DIGITS; j++){
    Display(j, digit_data[j]);
    delay(2);
  }
}

Enfin, nous reprenons la fonction qui nous permet d’envoyer les messages MIDI

void MIDImessage(byte command, byte MIDInote, byte MIDIvelocity) {
  Serial.write(command);//send note on or note off command
  Serial.write(MIDInote);//send pitch data
  if (command == noteON || command == noteOFF) {
    Serial.write(MIDIvelocity);//send velocity data
  }
}

Il ne nous reste plus qu’à envoyer le message lorsqu’un bouton est pressé

void readAbtn() { /* function readAbtn */
  //// Read button states from keypad
  btnId = getABtn();
  if (btnId) {
    if (lastBtnId != btnId) {
      MIDImessage(noteOFF, pitches[lastBtnId - 1], velocity);
    }
    MIDImessage(noteON, pitches[btnId - 1], velocity); //turn note on
    lastBtnId = btnId;
  }
}

Code Complet de la MIDIbox

byte velocity = 50;//velocity of MIDI notes, must be between 0 and 127
byte noteON = 144;// = 10010000 , Note On
byte noteOFF = 128;// = 10000000 , Note Off
byte pitchBend = 224; // = 11100000, Pitch Bender Change
byte polyKey = 160; // = 10100000, Polyphonic Key Pressure
byte overallPr = 208; // = 11010000, Overall Pressure
byte prgmChg = 192; // = 11000000, Program Change
byte ctrlChg = 176; // = 10110000,  Control Change

//Keypad
#define nbABtn 16
const int abtnPin = A1;
const int valThresh[nbABtn] = {1000, 900, 820, 750, 660, 620, 585, 540, 500, 475, 455, 425, 370, 300, 260, 200};
const int pitches[nbABtn] = {50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80 };
bool btnPressed = false;

//Potentiometer
const int potPin = A0; // Pin connected to sensor
int velVal = 0, oldVel = 0; // Analog value from the sensor

//rotary var
const int clkPin  = 53;
const int dtPin  = 51;
const int swPin  = 49;
int rotVal  = 0, btnId = 0, lastBtnId = 0;
bool clkState  = LOW;
bool clkLast  = HIGH;
bool swState  = HIGH;
bool swLast  = HIGH;

//4x7Segment
#define NUM_OF_DIGITS 4
int latch = 4; //74HC595  pin 9 STCP
int cs = 5; //74HC595  pin 10 SHCP
int data = 3; //74HC595  pin 8 DS
int dPins[4] = {8, 9, 10, 11};
//  DP G F E D C B A
//0: 1 1 0 0 0 0 0 0 0xc0
//1: 1 1 1 1 1 0 0 1 0xf9
//2: 1 0 1 0 0 1 0 0 0xa4
//3: 1 0 1 1 0 0 0 0 0xb0
//4: 1 0 0 1 1 0 0 1 0x99
//5: 1 0 0 1 0 0 1 0 0x92
//6: 1 0 0 0 0 0 1 0 0x82
//7: 1 1 1 1 1 0 0 0 0xf8
//8: 1 0 0 0 0 0 0 0 0x80
//9: 1 0 0 1 0 0 0 0 0x90
unsigned char table[] =
{0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90};
int digit_data[NUM_OF_DIGITS] = {0};
unsigned int number = 0;
unsigned long previousUpdate = 0, updateTime = 200;

void setup() {
  Serial.begin(115200);
  pinMode(potPin, INPUT);

  pinMode(clkPin, INPUT);
  pinMode(dtPin, INPUT);
  pinMode(swPin, INPUT_PULLUP);

  pinMode(latch, OUTPUT);
  pinMode(cs, OUTPUT);
  pinMode(data, OUTPUT);
  for (int j = 0; j < NUM_OF_DIGITS; j++) pinMode(dPins[j], OUTPUT);
}

void loop() {
  readRotary();
  updateDigits();
  readAbtn();
  readPot();
}

void MIDImessage(byte command, byte MIDInote, byte MIDIvelocity) {
  Serial.write(command);//send note on or note off command
  Serial.write(MIDInote);//send pitch data
  if (command == noteON || command == noteOFF) {
    Serial.write(MIDIvelocity);//send velocity data
  }
}


void readAbtn() { /* function readAbtn */
  //// Read button states from keypad
  btnId = getABtn();
  if (btnId) {
    if (lastBtnId != btnId) {
      MIDImessage(noteOFF, pitches[lastBtnId - 1], velocity);
    }
    MIDImessage(noteON, pitches[btnId - 1], velocity); //turn note on
    lastBtnId = btnId;
  }
}

int getABtn() { /* function getABtn */
  //// Read button states from keypad
  int val = analogRead(abtnPin);
  if (val <= 200) {
    return 0;
  } else {
    for (int i = 0; i < 16; i++) {
      if (val > valThresh[i]) {
        delay(100);
        return i + 1;
      }
    }
  }
}

//Potentiometer
void readPot(){
  velVal = map(int(analogRead(potPin) / 10) * 10, 0, 1023, 0, 127);
  if (oldVel != velVal) {
    //Serial.println(velVal);
    velocity = velVal;
  }
  oldVel = velVal;
}

//7Segment
void Display(int id, unsigned char num)
{
  digitalWrite(latch, LOW);
  shiftOut(data, cs, MSBFIRST, table[num]);
  digitalWrite(latch, HIGH);
  for (int j = 0; j < NUM_OF_DIGITS; j++) digitalWrite(dPins[j], LOW);
  digitalWrite(dPins[id], HIGH);
}

void updateDigits() {
  for (int j = 0; j < NUM_OF_DIGITS; j++)
  {
    Display(j, digit_data[j]);
    delay(2);
  }
}

//rotary
void readRotary( ) { /* function readRotary */
  ////Test routine for Rotary
  // gestion position
  clkState = digitalRead(clkPin);
  if ((clkLast == LOW) && (clkState == HIGH)) {//rotary moving
    if (digitalRead(dtPin) == HIGH) {
      rotVal = rotVal - 1;
      if ( rotVal < 0 ) {
        rotVal = 0;
      }
    }
    else {
      rotVal++;
      if ( rotVal > 127 ) {
        rotVal = 127;
      }
    }
    MIDImessage(prgmChg, rotVal, 0);
    number = rotVal;
    for (int i = 0; i < NUM_OF_DIGITS; i++)
    {
      digit_data[i] = number % 10;
      number /= 10;
    }
    delay(200);

  }
  clkLast = clkState;

  //gestion bouton
  swState = digitalRead(swPin);
  if (swState == LOW && swLast == HIGH) {
    delay(100);//debounce
  }
  swLast = swState;
}

Résultat

Pour tester le code, vous devez ouvrir les programme hairless et VirtualMIDISynth comme décrit dans cet article.

Si tout est bien configuré, vous devriez entendre des sons provenant de votre ordinateur lorsque vous appuyer sur les touches du clavier.

Vous pouvez également modifier la vitesse de la note en jouant sur le potentiomètre.

Entre deux notes jouées, vous pouvez ensuite sélectionner un autre instrument du synthétiseur à l’aide de l’encodeur rotatif.

Prochaines étapes

  • Utilisation de led ou bouton lumineux
  • Gestion du MIDI In afin d’allumer les LEDs
  • Utilisation d’un écran OLED afin d’avoir un menu plus complet

Sources

Générer des Sons avec une interface MIDI Arduino

Générer des Sons avec une interface MIDI Arduino

Afin de générer des sons synthétiques sur votre ordinateur à l’aide d’une interface et créer de la musique, il est possible de transformer un Arduino en appareil MIDI.

Matériel

  • Ordinateur
  • Arduino avec port USB

Introduction au protocole MIDI

Le MIDI (Musical Instrument Digital Interface) est un protocole de communication entre instruments électroniques, contrôleurs et logiciel de musique. Il consiste à envoyer une série d’octets (commande puis données) à une vitesse de 31250 (baudrate) pour spécifier le type de message (jouer note, arrêter note, changer programme, etc.) et les informations associées (note jouée, programme sélectionné, etc.). Voici un résumé des messages MIDI.

Code pour envoyer des messages MIDI avec Arduino

Nous allons voir comment envoyer les messages MIDI via le port série. Dans cette exemple, nous allons envoyer des commandes de note successivement. Comme si on appuyait sur différentes touches d’un piano. Pour cela nous envoyons les informations suivantes dans un ordre précis:

  • commande noteOn ou Off jouer la note ou l’arrêter
  • la note jouée ou pitch
  • vitesse à laquelle la touche est enfoncée

Un grand nombre de messages existent dans le protocole MIDI afin d ‘effectuer différentes action comme changer d’instrument, moduler les notes, etc.

 int velocity = 100;//velocity of MIDI notes, must be between 0 and 127
 //higher velocity usually makes MIDI instruments louder
 
 int noteON = 144;//144 = 10010000 in binary, note on command
 int noteOFF = 128;//128 = 10000000 in binary, note off command

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

void loop() {
  for (int note=50;note<70;note++) {//from note 50 (D3) to note 69 (A4)
    MIDImessage(noteON, note, velocity);//turn note on
    delay(300);//hold note for 300ms
    MIDImessage(noteOFF, note, velocity);//turn note off
    delay(200);//wait 200ms until triggering next note
  }
}

void MIDImessage(int command, int MIDInote, int MIDIvelocity) {
  Serial.write(command);//send note on or note off command 
  Serial.write(MIDInote);//send pitch data
  Serial.write(MIDIvelocity);//send velocity data
}

Téleversez ce code dans le microcontrôleur Arduino avant de passer à la suite.

N.B.: la vitesse de communication MIDI est de 31250. Dans cet exemple, nous allons utiliser un convertisseur MIDI/Serial. Nous pouvons donc utiliser n’importe quel baudrate.

Configuration de génération de son MIDI avec Windows

Configurer un instrument MIDI virtuel

Pour générer du son, il nous faut un logiciel de synthèse de son ou un DAW (Digital Audio Workstation). Les DAW peuvent être assez compliqués à prendre en main. Pour ce tutoriel, nous allons utiliser un synthétiseur de son virtuel très simple: CoolSoft Virtual MIDI Synth.

  • Téléchargez et installer le logiciel CoolSoft
  • Dans l’onglet MIDI Mapper, sélectionnez VirtualMIDISynth dans le périphérique par défaut de Windows Media Player
  • Dans l’onglet Option, sélectionnez le périphérique de sortie audio
  • Appuyez sur “Appliquer”

Pour que le logiciel de synthèse fonctionne, il faut utiliser une base de son (SoundFont) pour convertir les messages MIDI en sons provenant d’un piano, par exemple. Vous pouvez retrouver une liste de SoundFonts sur la page de CoolSoft. Il vous suffit ensuite de télécharger le fichier .sf2 que vous souhaitez et l’ajouter dans l’interface CoolSoft.

Configurer le convertisseur Série vers MIDI

La communication MIDI est un protocole particulier différent de la communication USB. Pour prendre en compte les messages MIDI envoyés par l’Arduino via le port USB, il va nous falloir un convertisseur Serial vers MIDI

Pour cela nous utilisons le logiciel Hairless Midi to Serial Bridge, qui va nous permettre de convertir les messages série en message MIDI.

  • Téléchargez et ouvrez le logiciel Hairless
  • Sélectionnez l’Arduino que vous avez branché sur votre PC dans la liste déroulante “Serial Port”
  • Sélectionnez ensuite VirtualMIDISynth dans la liste déroulante “MIDI Out”

Si vous activez le Debug MIDI messages, vous devriez voir défiler les notes jouées et leurs vitesses.

Si la sortie audio de votre ordinateur est activée, vous dévriez entendre des notes de musique.

N.B.: Vous ne pourrez pas téléverser de code dans l’Arduino si la case Serial <->MIDI Bridge On est cochée.

Vous avez, à présent, créé votre première interface MIDI avec Arduino et pouvez faire vos premiers pas dans la synthèse sonore.

Applications

  • Créer un contrôleur MIDI avec Arduino, des boutons et potentiomètres.

Sources

Utilisation d’un Buzzer avec Arduino

Utilisation d’un Buzzer avec Arduino

Il est possible d’émettre des sons à l’aide d’un microcontrôleur en branchant un buzzer sur une de ses sorties. Lorsqu’on veut créer une interface utilisateur, il est agréable d’avoir un retour selon les actions effectuées que ce soit un affichage, une lumière qui s’allume, ou change de couleur, ou encore un son. Nous allons voir dans ce tutoriel comment utilisé un buzzer (ou haut-parleur piézoélectrique).

Matériel

  • Ordinateur
  • Arduino UNO
  • Câble USB A Mâle/B Mâle
  • Buzzer

Principe de fonctionnement

Un buzzer est une sorte de haut-parleur mais de faible puissance qui va émettre un son en fonction de la fréquence et amplitude de vibration. Il permet de jouer des notes et de recréer des mélodies simples. Si vous souhaitez jouer des sons comme de la musique ou des voix, il vous faudra utiliser un haut-parleur avec un amplificateur audio qui viendra jouer un fichier audio stocké sur une carte SD.

Pour jouer des fichiers audio, vous pouvez suivre ce tutoriel.

Schéma

Un buzzer étant de faible puissance, il peut être branché directement sur le microcontrôleur sur n’importe laquelle de ses broches de sorties. Dans ce tutoriel, nous branchons la borne – du buzzer au GND et la borne + à la sortie digitale 2.

Code

Pour chaque note correspond un fréquence qui est enregistrée dans le fichier pitches.h. Pour jouer une mélodie, nous allons placer les notes dans un tableau et spécifier un retard entre chaque notes. Nous utilisons ensuite la fonction tone pour appliquer cette fréquence et cette durée à la sortie du buzzer.
Pour créer le fichier pitches, cliquez sur la flèche à droite du nom du sketch, puis cliquez sur “créer un nouvel onglet”. Copier-collez ensuite le code avec la définition des notes.

Fichier .ino

//Libraries
#include "pitches.h" //https://www.arduino.cc/en/Tutorial/BuiltInExamples/toneMelody

//Parameters
const int buzPin  = 2;

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
}

void loop() {
  playPassed();
  delay(1000);
  playFailed();
  delay(2000);
}

void playPassed() { /* function playPassed */
  ////Play 'ON' Sound
  int melodyOn[] = {NOTE_C5, NOTE_C6, NOTE_D5, NOTE_A6};
  int durationOn = 200;
  for (int thisNote = 0; thisNote < 4; thisNote++) {
    tone(buzPin, melodyOn[thisNote], durationOn);
    delay(200);
  }
}

void playFailed() { /* function playFailed */
  ////Play 'OFF' Sound
  int melodyOff[] = {NOTE_C3, NOTE_D3};
  int durationOff = 200;
  for (int thisNote = 0; thisNote < 2; thisNote++) {
    tone(buzPin, melodyOff[thisNote], durationOff);
    delay(200);
  }
}

Fichier pitches.h

/*************************************************

 * Public Constants

 *************************************************/

#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978

Résultat

Modifier les notes, la taille des tableaux et les délais pour recréer les mélodies que vous voulez.

Applications

  • Créer un clavier interactif avec retour sonore
  • Créer un robot qui émet des sons comme R2-D2

Sources

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie

Utilisation d’un Microphone avec Arduino

Utilisation d’un Microphone avec Arduino

Il est possible de rajouter le sens de l’ouïe à votre microcontrôleur en le connectant à un microphone. Le microphone capte les vibrations de l’air et les transforme en signal électrique qu’il est possible d’analyser et de traiter à l’aide d’un algorithme. Dans ce tutoriel, nous allons voir comment détecter un niveau sonore à l’aide du microcontrôleur.

Matériel

  • Ordinateur
  • Arduino UNO
  • Câble USB A Mâle/B Mâle
  • Microphone

Principe de fonctionnement

Le capteur utilisé dans ce tutoriel est un microphone à condensateur électrique. Il est composé de deux plaques l’une fixe et l’autre mobile. Les vibrations de l’air se transforme en déplacement de la membrane mobile ce qui crée une variation de potentiel électrique détecté par le capteur et qui envoie un signal électrique au microcontrôleur. Il existe plusieurs modèles de microphone avec des sensibilités différentes pour détecter des sons plus ou moins fort. Un modèle peut être plus adapté qu’un autre selon ce que vous souhaitez faire. Vérifiez bien la documentation du module.

Ce genre de module ne permet pas d’enregistrer ou d’analyser un son complexe mais plutôt un niveau sonore.

Schéma

Le microphone nécessite une faible puissance et peut être alimenté directement sur la broche 5V de l’Arduino. Il renvoie une valeur analogique qui sera envoyé sur une entrées analogique du microcontrôleur. Selon le modèle utilisé, un potentiomètre est présent sur le module afin de régler la sensibilité du microphone.

  • AUD à la broche A0
  • Vcc à la broche 5V
  • GND à la broche GND

Code

Pour mesurer le niveau sonore, nous employons la fonction AnalogRead() comme pour la plupart des capteurs analogiques.

//Parameters
const int micPin  = A0;

//Variables
int micVal  = 0;

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  //Init Microphone
  pinMode(micPin, INPUT);
}

void loop() {
  readMicrophone();
}

void readMicrophone( ) { /* function readMicrophone */
  ////Test routine for Microphone
  micVal = analogRead(micPin);
  Serial.print(F("mic val ")); Serial.println(micVal);
  if (micVal > 600) {
    Serial.println("mic detected");
  }
}

Résultat

Une fois le code chargé dans le microcontrôleur vous devriez voir la valeur analogique évoluer en fonction du bruit ambiant. Essayer de taper des mains, de claquer des doigts ou de parler pour voir comment se comporte le microphone. Vous pourrez ainsi déterminer le niveau nécessaire pour déclencher une action.

Applications

  • Activer une lampe par un battement de mains
  • Créer une alarme qui s’active au bruit

Sources

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie

Donnez de la voix à votre projet Arduino

Donnez de la voix à votre projet Arduino

Pour rendre votre projet Arduino plus interactif, il peut être amusant d’émettre des sons en fonction de certaines actions. Dans ce tutoriel, nous allons voir comment jouer un fichier audio WAV enregistré sur une carte SD avec Arduino.

Prérequis: Lire et écrire sur une carte SD, Créer ou modifier un fichier audio pour Arduino

Matériel

  • Ordinateur
  • Arduino UNO x1
  • câble USB pour connecter l’Arduino à l’ordinateur x1
  • Shield ou module pour carte SD x1
  • Amplificateur Audio ou un module transistor x1
  • Haut-parleur x1

Schéma de câblage

Le schéma de câblage peut varier en fonction de ce que vous utiliser. Voici quelques remarques pour vous aider à adapter ce tuto à votre projet: Dans notre exemple, La broche CS (Chip Select) du module de carte SD est connectée à la broche 10 pour communiquer avec la carte Arduino. Cette broche peut varier en fonction du shield utilisé et en fonction de l’endroit où vous connectez la broche. Pour plus d’information sur la connexion du module carte SD, lisez cet article. Sur la carte Arduino UNO, seule la broche 9 est compatible avec la librairie TMRpcm.h. Référez vous à la documentation (5,6,11 ou 46 pour Mega, 9 pour Uno, Nano, etc.) Selon le haut-parleur utilisé, il est préférable de choisir une source de tension externe pour alimenter le haut-parleur afin de ne pas endommager la carte Arduino.  

Code pour jouer un fichier Audio

Placer le fichier WAV sur la carte SD puis insérez-là dans le module SD Card. Vous pouvez ensuite charger le code suivant dans la carte Arduino. Pour jouer le fichier audio, nous allons utiliser la librairie TMRPcm.h qui permet de jouer des fichiers audio WAV de manière asynchrone à partir d’une carte SD. Dans cet exemple, le fichier audio est joué toutes les secondes. Fonctions à connaître:

  • tmrpcm.play(char*) pour jouer le fichier
  • tmrpcm.setVolume(int) pour régler le volume du haut-parleur
  • tmrpcm.stopPlayback() ou tmrpcm.disable() pour arrêter la lecture
  • tmrpcm.isPlaying() pour savoir si le fichier est en train d’être jouer

Pour plus d’information, reportez-vous à la documentation.

//Libraries
#include <SD.h>
#include <TMRpcm.h>

//Constants
#define SD_ChipSelectPin 10//4 
const int speakerPin = 9;
char* file = "bonjour.wav";

//Variables
unsigned long previousTime = 0;
unsigned long interval = 1000;
//Objects
TMRpcm tmrpcm;
/*******************************************************************
                                 MAIN
*******************************************************************/
void setup() {
  /* function setup */
  Serial.begin(9600);
  //Init sd shield
  if (!SD.begin(SD_ChipSelectPin)) {
    Serial.println("SD fail");
    return;
  }

  //Init speaker
  tmrpcm.speakerPin = speakerPin;
  tmrpcm.setVolume(3);
}

void loop() {
  /* function loop */
  if (millis() - previousTime > interval) {
    activateOutput();
    previousTime = millis();
  }
}
/*******************************************************************
                                 FUNCTIONS
 *******************************************************************/
void activateOutput() {
  /* function activateOutput */
  Serial.println("Play sound");
  tmrpcm.play(file);
  while (tmrpcm.isPlaying()) {} //wait until file is played
  //delay(1000);tmrpcm.stopPlayback(); // or wait 1sec and stop music
}

N.B.: dans la fonction activateOutput(), vous avez le choix de ne pas attendre que le fichier soit lu pour effectuer d’autres actions. Pour cela il vous suffit de commenter la ligne avec while.   Vous pouvez désormais jouer n’importe quel son avec votre carte Arduino.  

Source

Prochaines étapes

Retrouvez nos tutoriels et d’autres exemples dans notre générateur automatique de code
La Programmerie