Faire une boite à musique avec une carte Arduino / Genuino et un module MP3 série

2 x 15 Watts de fun

par skywodd | Oct. 16, 2016 | Licence (voir pied de page)

Catégories : Projets | Mots clefs : Arduino Genuino Serial UART MP3 KT403A

Cet article n'a pas été mis à jour depuis un certain temps, son contenu n'est peut être plus d'actualité.

Dans cet article, je vous propose de découvrir un projet de boite à musique qui m'a été commandé par un client du TamiaLab. Le but de ce projet : déclencher la lecture d'un fichier audio lors de l'appui sur un bouton. Ajoutez à cela un amplificateur audio et quelques boutons en plus et vous obtenez la boite à musique que je vous présente dans cet article.

Sommaire

• Le montage
• Test des boutons
• Le code du projet
• Bonus : Le produit fini
• Conclusion

Bonjour à toutes et à tous !

Dans un précédent article, nous avons vu ensemble comment utiliser un module MP3 série avec une carte Arduino / Genuino. Ce précédent tutoriel n'était qu'une mise en bouche en attendant la publication de cet article.

Mon client avait besoin d'une boite à musique pour jouer divers fonds et effets sonores pour un costume. Son projet était simple, mais très intéressant. Celui-ci consisté à intégrer dans un boitier de petite taille une série de 12 boutons, un lecteur MP3, une carte de contrôle, ainsi qu'un amplificateur audio d'une puissance suffisante pour que le public autour du costume se retourne. Le tout devait être portable (fonctionnement sur batterie obligatoire), léger et ne devait pas trop chauffer.

Le montage

Pour réaliser ce projet, j'ai utilisé :

• Une carte Arduino Pro Mini,

• Un module MP3 "Grove V2.0" de SeeedStudio,

• Un amplificateur 2 x 15 Watts,

• Douze boutons miniatures de type "arcade",

• Un jeu de connecteurs DC male / femelle pour la batterie,

• Deux jeux de connecteurs audio "jack" (mono) male / femelle pour les haut-parleurs,

• Un connecteur audio "jack" 3.5mm,

• Deux résistances de 100 ohms et deux résistances de 47K ohms,

• Un régulateur de tension 5 volts,

• Un boitier aluminium de 102 x 72 x 44 mm,

• Quelques visseries et des fils pour câbler le montage.

J'ai choisi d'utiliser une carte Arduino Pro Mini pour ce projet, car cette carte est suffisamment petite pour rentrer dans le boitier tout en disposant de suffisant d'entrées / sorties pour les boutons. Une fois programmée, la carte Arduino ne nécessitera pas de mises à jour du code par l'utilisateur. La connectique USB d'une carte Arduino classique n'était donc pas utile pour ce projet.

L'amplificateur audio que j'ai sélectionné pour ce projet est une carte construite autour d'un circuit intégré TDA7297 de ST Micro. La carte complète coûtait autant que le circuit intégré amplificateur seul (vive la production en masse). Cela m'a permis d'économiser quelques euros en composants passifs sur le budget du projet.

Le boitier aluminium a été choisi pour deux raisons : premièrement l'aluminium est bien plus solide que du plastique. C'est un détail qui a son importance vu le contexte dans lequel le montage sera utilisé (dans un costume). Deuxièmement, l'aluminium du boitier peut servir de radiateur pour l'amplificateur audio, ce qui me fait gagner de la place.

N.B. Comme vous le verrez plus bas, j'ai dû ajouter un régulateur de tension 5 volts ainsi que quelques résistances au montage. La photo ci-dessus a été prise au tout début du projet. Le schéma ci-dessous est à jour.

Le schéma de montage final peut paraitre compliqué à première vue, mais en réalité il est assez simple.

J'ai commencé le câblage du projet par un démontage partiel de la carte électronique de l'amplificateur.

Les borniers ne sont pas utiles pour le projet vu que les fils sont directement soudés sur la carte. Je les ai donc dessoudés de la carte. J'ai aussi retiré le connecteur audio pour la même raison.

Afin de gagner un peu de place en hauteur pour les boutons, j'ai retiré le condensateur d'alimentation de la carte. J'ai par la même occasion dessoudé le potentiomètre de réglage du volume pour le déporté plus tard sur le côté du boitier.

J'ai ensuite commencé le gros du travail.

Le potentiomètre de réglage du volume a été déporté via une petite longueur de fils pour pouvoir être monté sur le côté du boitier en aluminium. Ensuite, deux connecteurs ont été soudés sur les sorties de l'amplificateur pour les haut-parleurs.

Au niveau de l'alimentation, j'ai mis en série un petit interrupteur ON/OFF avec un connecteur d'alimentation pour batterie 12 volts (avec le plus au centre). J'ai soudé le tout à l'emplacement du bornier d'alimentation de l'amplificateur.

N.B. La carte de l'amplificateur dispose d'une diode de protection en cas d'inversion de polarité de la batterie.

J'ai ressoudé le condensateur d'alimentation en le déportant de quelques centimètres via deux fils. Cela me permet de le fixer dans le boitier à l'horizontale. J'ai aussi câblé en parallèle un régulateur de tension 5 volts en boitier TO-220. Ce régulateur alimente la carte Arduino en 5 volts via la broche RAW.

PS J'ai été obligé d'ajouter ce régulateur 5 volts, car le régulateur intégré dans la carte Pro Mini ne supporter pas plus de 8 volts. Au-dessus de 8 volts, la protection de surtension s'activer et faisait redémarrer sans cesse la carte Arduino.

Le module MP3 est relié aux broches RX et TX de la carte Arduino, ainsi qu'à la masse et à la broche VCC de la carte Arduino. J'ai utilisé le connecteur "Grove" de la carte Seeedstudio à mon avantage en coupant une extrémité du câble. Il est ainsi possible de déconnecter le module MP3 pour accéder facilement à la carte micro SD en dessous.

Pour finir, j'ai câblé les douze boutons poussoirs et la LED d'état avec des fils sur les broches D2 à D13 et A0 de la carte Arduino. Les boutons sont câblés entre une broche de la carte Arduino (configurée en entrée avec résistance tirage interne) et la masse. La LED d'état est câblée avec une résistance de limitation de courant de 330 ohms en série avec la LED.

N.B. La LED est sur la broche D13 et le deuxième bouton sur la broche A0, car la LED incluse dans la carte Pro Mini rend inutilisable la broche D13 en tant qu'entrée avec résistance de tirage.

Toutes les connexions ont été protégées avec une bonne quantité de gaine thermorétractable. Les divers fils ont été zippés avec des colliers de serrage pour éviter les pincements. Et au niveau de la carte de l'amplificateur, les points de soudures ont été noyés dans une bonne dose de colle chaude pour éviter que les soudures ne se cassent avec les vibrations.

N.B. J'ai ajouté lors du montage une petite feuille de plastique rigide au fond du boitier pour éviter les courts-circuits. J'ai aussi ajouté un peu de patte thermique entre le boitier en aluminium, le régulateur et tension et l'amplificateur, pour le principe.

PS "Dans le doute, ajoute de la colle chaude et des colliers de serrage", c'est ma devise.

Test des boutons

Une fois le câblage terminé, j'ai conçu un petit code de test pour les divers boutons. C'est ainsi que j'ai pu remarquer le souci avec la broche D13 mentionnée plus haut.

1
2
3
4
5
6
7
8
9

/* Constantes pour les boutons */
const byte BUTTONS_PIN[] = {
  2, 3, 4, 5, 6, 7,
  8, 9, 10, 11, 12, A0
};
const byte BUTTONS_COUNT = 12;

/* Constantes pour le reste du montage */
const byte STATUS_LED_PIN = 13;

Le code commence avec la déclaration des broches pour les boutons et la LED d'état. J'utilise un tableau pour les broches des boutons afin de simplifier le reste du code.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

/** Fonction setup() */
void setup() {
  
  /* Place les boutons en entrées avec pull-up */
  for (byte i = 0; i < BUTTONS_COUNT; ++i) {
    pinMode(BUTTONS_PIN[i], INPUT_PULLUP);
  }
  
  /* Place la LED de statut en sortie */
  pinMode(STATUS_LED_PIN, OUTPUT);
  digitalWrite(STATUS_LED_PIN, LOW);

  /* Initialise le port série */  
  Serial.begin(9600);
}

La fonction setup() configure les broches des boutons en entrées et active les résistances de tirage internes. La broche de la LED d'état est configurée en sortie et le port série est initialisé à 9600 bauds.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

/** Fonction loop() */
void loop() {
 
  /* Test chaque bouton */
  for (byte i = 0; i < BUTTONS_COUNT; ++i) {
    
    /* Bouton actif ? */
    if (digitalRead(BUTTONS_PIN[i]) == LOW) {
      Serial.write('X');
    } else {
      Serial.write(' ');
    }
  }
  Serial.println();
  
  digitalWrite(STATUS_LED_PIN, LOW);
  delay(500);
  digitalWrite(STATUS_LED_PIN, HIGH);
  delay(500);
}

La fonction loop() scrute continuellement l'état des boutons et affiche un X sur le port série si un bouton est appuyé ou un espace dans le cas contraire. En parallèle, le code de la fonction fait clignoter la LED d'état pour s'assurer de son bon fonctionnement.

Le code complet avec commentaires :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

/**
 * Code de test pour les entrées d'une carte Arduino UNO.
 */ 
 

/* Constantes pour les boutons */
const byte BUTTONS_PIN[] = {
  2, 3, 4, 5, 6, 7,
  8, 9, 10, 11, 12, A0
};
const byte BUTTONS_COUNT = 12;

/* Constantes pour le reste du montage */
const byte STATUS_LED_PIN = 13;


/** Fonction setup() */
void setup() {
  
  /* Place les boutons en entrées avec pull-up */
  for (byte i = 0; i < BUTTONS_COUNT; ++i) {
    pinMode(BUTTONS_PIN[i], INPUT_PULLUP);
  }
  
  /* Place la LED de statut en sortie */
  pinMode(STATUS_LED_PIN, OUTPUT);
  digitalWrite(STATUS_LED_PIN, LOW);

  /* Initialise le port série */  
  Serial.begin(9600);
}


/** Fonction loop() */
void loop() {
 
  /* Test chaque bouton */
  for (byte i = 0; i < BUTTONS_COUNT; ++i) {
    
    /* Bouton actif ? */
    if (digitalRead(BUTTONS_PIN[i]) == LOW) {
      Serial.write('X');
    } else {
      Serial.write(' ');
    }
  }
  Serial.println();
  
  digitalWrite(STATUS_LED_PIN, LOW);
  delay(500);
  digitalWrite(STATUS_LED_PIN, HIGH);
  delay(500);
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

Le code du projet

Le "vrai" code du projet est un mix entre le code de test du chapitre précédent et le code d'exemple de mon tutoriel d'utilisation du module MP3 (voir lien en bas de page).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

/* Constantes pour les boutons */
const byte BUTTONS_PIN[] = {
  2, 3, 4, 5, 6, 7,
  8, 9, 10, 11, 12, A0
};
const byte BUTTONS_COUNT = 12;

/* Constantes pour le reste du montage */
const byte STATUS_LED_PIN = 13;

/* Constantes pour la communication avec le module KT403A */
const byte COMMAND_BYTE_START = 0x7E;
const byte COMMAND_BYTE_VERSION = 0xFF;
const byte COMMAND_BYTE_STOP = 0xEF;

/* Constantes pour la commande selectSourceDevice() */
const byte DEVICE_UDISK = 0x01;
const byte DEVICE_SDCARD = 0x02;


/** Reset the MP3 module */
void resetPlayer() {
  send_kt_command(0x0C, 0, 0, 100);
}

/** Select the source device for playing */
void selectSourceDevice(byte device) {
  send_kt_command(0x09, 0, device, 200);
}

/** Set the volume to the given level (0 ~ 30) */
void setVolume(byte volume) {
  if (volume > 30) volume = 30;
  send_kt_command(0x06, 0, volume, 10);
}

/** Select the source track from the "MP3" (case insensitive) folder */
void selectSourceTrackInMp3Directory(uint16_t track_number) {
  // Assert 0 ~ 9999
  send_kt_command(0x12, highByte(track_number), lowByte(track_number), 10);
}

/** Fonction de bas niveau pour envoyer une commande au module KT403A */
void send_kt_command(byte command, byte data_h, byte data_l, unsigned long cmd_delay) {
  Serial.write(COMMAND_BYTE_START);
  Serial.write(COMMAND_BYTE_VERSION);
  Serial.write((byte) 0x06);
  Serial.write(command);
  Serial.write((byte) 0x00);
  Serial.write(data_h);
  Serial.write(data_l);
  Serial.write(COMMAND_BYTE_STOP);
  // 16-bits checksum is optionnal
  delay(cmd_delay);
}

Le code commence avec la déclaration des broches pour les boutons et la LED d'état. Ainsi que des diverses fonctions et constantes pour la communication avec le module MP3.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

/** Fonction setup() */
void setup() {
  
  /* Place les boutons en entrées avec pull-up */
  for (byte i = 0; i < BUTTONS_COUNT; ++i) {
    pinMode(BUTTONS_PIN[i], INPUT_PULLUP);
  }
  
  /* Place la LED de statut en sortie */
  pinMode(STATUS_LED_PIN, OUTPUT);
  digitalWrite(STATUS_LED_PIN, HIGH);

  /* Initialise le port série */  
  Serial.begin(9600);
  
  /* Initialise le module KT403A */
  resetPlayer();
  selectSourceDevice(DEVICE_SDCARD);
  setVolume(15);
}

La fonction setup() configure les broches des boutons en entrées et active les résistances de tirage internes. La broche de la LED d'état est configurée en sortie et le port série est initialisé à 9600 bauds. Pour finir, le module MP3 est initialisé en mode carte SD.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

/** Fonction loop() */
void loop() {
 
  /* Test chaque bouton */
  for (byte i = 0; i < BUTTONS_COUNT; ++i) {
    
    /* Bouton actif ? */
    if (digitalRead(BUTTONS_PIN[i]) == LOW) {
      digitalWrite(STATUS_LED_PIN, LOW);
      
      /* Joue la musique */
      selectSourceTrackInMp3Directory(i + 1);
      delay(40);
      
      /* Attend que le bouton soit relâché */
      while(digitalRead(BUTTONS_PIN[i]) == LOW);
      delay(40);
      
      digitalWrite(STATUS_LED_PIN, HIGH);
    }
  }
}

La fonction loop() scrute continuellement chaque bouton. Si un bouton est appuyé, le code de la fonction lance la musique associée avec le bouton et attend que le bouton soit relâché. Cela évite de relancer en boucle la musique tant que le bouton est appuyé et filtre les rebonds mécaniques des boutons.

PS A chaque appui sur un bouton, la LED d'état clignote pour indiquer que l'électronique fonctionne.

Le code complet avec commentaires :

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107

/**
 * Boite à samples avec une carte Arduino et un module MP3 KT403A.
 * Permet de lire 12 échantillons audio via 12 boutons poussoir.
 */


/* Constantes pour les boutons */
const byte BUTTONS_PIN[] = {
  2, 3, 4, 5, 6, 7,
  8, 9, 10, 11, 12, A0
};
const byte BUTTONS_COUNT = 12;

/* Constantes pour le reste du montage */
const byte STATUS_LED_PIN = 13;

/* Constantes pour la communication avec le module KT403A */
const byte COMMAND_BYTE_START = 0x7E;
const byte COMMAND_BYTE_VERSION = 0xFF;
const byte COMMAND_BYTE_STOP = 0xEF;

/* Constantes pour la commande selectSourceDevice() */
const byte DEVICE_UDISK = 0x01;
const byte DEVICE_SDCARD = 0x02;


/** Reset the MP3 module */
void resetPlayer() {
  send_kt_command(0x0C, 0, 0, 100);
}

/** Select the source device for playing */
void selectSourceDevice(byte device) {
  send_kt_command(0x09, 0, device, 200);
}

/** Set the volume to the given level (0 ~ 30) */
void setVolume(byte volume) {
  if (volume > 30) volume = 30;
  send_kt_command(0x06, 0, volume, 10);
}

/** Select the source track from the "MP3" (case insensitive) folder */
void selectSourceTrackInMp3Directory(uint16_t track_number) {
  // Assert 0 ~ 9999
  send_kt_command(0x12, highByte(track_number), lowByte(track_number), 10);
}

/** Fonction de bas niveau pour envoyer une commande au module KT403A */
void send_kt_command(byte command, byte data_h, byte data_l, unsigned long cmd_delay) {
  Serial.write(COMMAND_BYTE_START);
  Serial.write(COMMAND_BYTE_VERSION);
  Serial.write((byte) 0x06);
  Serial.write(command);
  Serial.write((byte) 0x00);
  Serial.write(data_h);
  Serial.write(data_l);
  Serial.write(COMMAND_BYTE_STOP);
  // 16-bits checksum is optionnal
  delay(cmd_delay);
}


/** Fonction setup() */
void setup() {
  
  /* Place les boutons en entrées avec pull-up */
  for (byte i = 0; i < BUTTONS_COUNT; ++i) {
    pinMode(BUTTONS_PIN[i], INPUT_PULLUP);
  }
  
  /* Place la LED de statut en sortie */
  pinMode(STATUS_LED_PIN, OUTPUT);
  digitalWrite(STATUS_LED_PIN, HIGH);

  /* Initialise le port série */  
  Serial.begin(9600);
  
  /* Initialise le module KT403A */
  resetPlayer();
  selectSourceDevice(DEVICE_SDCARD);
  setVolume(15);
}


/** Fonction loop() */
void loop() {
 
  /* Test chaque bouton */
  for (byte i = 0; i < BUTTONS_COUNT; ++i) {
    
    /* Bouton actif ? */
    if (digitalRead(BUTTONS_PIN[i]) == LOW) {
      digitalWrite(STATUS_LED_PIN, LOW);
      
      /* Joue la musique */
      selectSourceTrackInMp3Directory(i + 1);
      delay(40);
      
      /* Attend que le bouton soit relâché */
      while(digitalRead(BUTTONS_PIN[i]) == LOW);
      delay(40);
      
      digitalWrite(STATUS_LED_PIN, HIGH);
    }
  }
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

Bonus : Le produit fini

En guise de bonus, voici quelques images du produit fini :

Et pour les plus curieux, voici le manuel d'utilisation que j'ai écrit pour ce projet : Manuel d'utilisation de la boite à musique (PDF).

Conclusion

Ce projet est désormais terminé.

Si ce projet vous a plu, n'hésitez pas à le commenter sur le forum, à le partager sur les réseaux sociaux et à soutenir le site si cela vous fait plaisir.

Cliquez ici pour accéder aux commentaires de l'article.