Détecter un signal électrique et lancer un événement - Raspberry

Auteur : Damien MUTI DESGROUAS

Date : avril 2020 - Confinement

Licence : libre !

Contexte : Apprentissage

Fichiers : liens éventuels

https:

Introduction

Dans ce tutoriel nous montrons comment, à l'aide d'un montage électronique spécifique et d'un ordinateur, il est possible de détecter un signal électrique afin de lancer un événement tel qu'un son ou un autre média. Nous allons appliquer ce montage et le programme associé à la détection électronique de la sonnerie du lycée qui au fil des mois devient plus qu'entêtante. L'idée serait de détecter le signal sonore envoyé par l'amplificateur central du lycée, jusqu'au haut parleur du couloir, de lancer un sample sonore aléatoire de même durée que la sonnerie sur l'ordinateur utilisé, de l'amplifier (via une chaîne hi-fi par exemple) et de le renvoyer sur le haut parleur du couloir.

Schéma du montage

Les logiciels de simulation électronique permettent de schématiser le montage associé. Ici nous avons utilisé le logiciel gratuit LT-Spice :

Le schéma N°1 correspond à une prise de signal avant le transformateur du haut parleur. Il implique une tension d'entrée de 100V environ (trop dangereux):

Le schéma N° 2 correspond à une prise de signal après le transformateur du haut parleur. Il implique une tension d'une dizaine de volt au maximum. Le transformateur permettant de diviser par 10 la tension porteuse du signal. Le signal utilisé est donc inoffensif. Le schéma du montage est le suivant :

Le matériel utilisé ici est le suivant (fournisseur Franlell):

D1: Diode faible perte DO-35 (ref : 1N456A)

AD8551 : Comparator CMOS RAIL/RAIL (ref: MAX941CPA+). Datasheet.

(Timmer, 100K, 0, 15W, 1 tour (Ref: PT10MV11-104A2020-PM-S))

R6,R7 : Résistance 1K, 0,25W 1% (ref: MF25 1K

R2,R5 : Résistance 1M, 0,25W 1% (ref: MF25 1M)

C1 et C3 : Condensateur 1uF, 250V, Film, Rad (ref : MPMEF250W10JOI200)

D2 : Diode Zener 500MW 4,7V (ref : BZX79-C4V7)

Principe de fonctionnement

Simulation LTSpice (schéma N°2)

Signal à différents points de mesures

Un agrandissement de la fenêtre à un instant où la tension est bien égale à 5V :

Signal envoyé par l’amplificateur sonore

Le signal délivré par l’amplificateur (V1) est signal sonore dont les fréquences correspondent aux fréquences audio classiques comprise sur l'intervalle [20Hz, 20kHz].

La tension délivrée à la sortie du transformateur K1 sur la ligne de diffusion est : s1(t) avec S1max ≈ 100V pour satisfaire la puissance totale nécessaire à l’alimentation de tous les Hauts Parleurs.

Il est préférable de mesurer le signal délivré à la sortie du deuxième transformateur K2. L'amplitude délivrée et beaucoup moins importante. La forme du signal est la suivante :

On remarque que le signal a une durée totale d'environ 18,5s. l'amplitude du signal varie entre environ +6,5V et -6,5V.

Masse flottante

Afin d’être en masse flottante pour détecter le signal électrique arrivant de l’amplificateur sonore nous choisissons de placer 2 condensateur C1 et C2 de 1µF pour prélever le signal.

L’objectif est d’effectuer un montage permettant d’obtenir une tension de 5V si le signal si le signal électrique associé à la sonnerie, prélevé à la sortie des deux condensateurs C1 et C2, est présent et de 0V sinon.

Nous plaçons la résistance R6 pour que le point de mesure en C2 ne soit pas flottant et soumis aux ondes électromagnétiques du milieu ambiant. Si cette résistance n'est pas présente, la tension à l'entrée V+ du comparateur peut être supérieure à celle en V- et donner une tension de sortie égale à 5V alors qu'il n'y a pas de signal réellement détecté.

Protection du comparateur

Le comparateur AD8551 est alimenté en [0V,5V]. Les caractéristiques sur la Datasheet (p2) précisent une “Differential Input Voltage” (tension d'entrée différentielle), c'est-à-dire, une tension négative sur la broche d'entrée de -0,3V. Il est donc nécessaire de protéger cette entrée à l'aide de la diode D2 qui va couper toutes les alternances négatives du signal d'entrée, et diminuer d'environ 0,6V (la tension de seuil de la diode) l'amplitude maximal de ce dernier.

Mise en forme du signal

Pour cela, nous utilisons tout d’abord une diode Zener D2 (1N750), associé à la résistance de R5 1MOhm, pour ne laisser passer que les alternances de tensions positives, et limiter les tensions supérieures à 4,7V. Cela permet de protéger la suite du montage.

Détection du signal

Nous utilisons ensuite un montage comparateur à Amplificateur Opérationnel comparateur, noté ici AD8551. Sur l’entrée V- du comparateur, il convient de placer un potentiomètre permettant de régler la tension de seuil de basculement de la tension de sortie Vs. En effet, la tension de sortie Vs = µ(V+ - V-), avec µ le gain de l’AO théoriquement infini de sorte que la tension de sortie vaut soit Vs = 5V, soit Vs = 0V. Le réglage de la tension d’entrée V- de référence permet d’éviter une fausse détection de la sonnerie qui serait causé par un bruit d’électronique. Si le signal d’entrée est inférieur à V-, la sortie vaut 0V. Si le signal d’entrée est supérieur à V-, la sortie est un signal rectangulaire 5V-0V de la même fréquence que le signal d’entrée.

Attention : La tension de référence du comparateur (patte n°3) doit être expérimentalement réglée aux alentour de 2,2V .

Mise en forme, détection d’enveloppe

La sortie de l'AO AD8551 délivre une tension, sous une impédance très faible, qui va servir à charger le condensateur C3 à travers la résistance R7. La diode permet de maintenir la charge du condensateur. La valeur de la tension de charge du condensateur est égale à la valeur pic (temporelle sur un cycle) de la tension de sortie de l'AO. Le condensateur se décharge au travers de la résistance R2, lorsque le signal à la sortie de l'AO devient nul.

Filtrage passe bas pour obtenir une tension constante (5V ou 0V)

En filtrant toutes les harmoniques (hautes fréquences) du signal carré obtenu précédemment, on récupère uniquement l’enveloppe du signal. Ceci est réalisé par les filtres RC composé de R7,C3 et R2, C3. La sortie vaut 0V si le signal d’entrée est inférieur à V- (réglable par potentiomètre). La sortie vaut 5V si le signal d’entrée est supérieur à V-.

Physiquement, ceci revient à charger le condensateur C3 (1µF) avec le signal de sortie du comparateur. Lorsque le signal d'entrée devient nul, ou qu'il est trop faible pour être détecté (ceci apparaît lorsqu'il y a des silence dans la musique issu de la sonnerie initiale), le condensateur C3 se décharge via la résistance R2.

Le temps caractéristique de décharge est Tau=R2*C3= 10^6*10^-6 = 1s. Ce temps permet ainsi de pouvoir continuer à lancer de la musique, même si les silences dans le signal d'entrée (la sonnerie du lycée) sont importants. en effet, le condensateur C3 reste quasiment chargé sur une durée d'environ 1s, permettant le maintient de la tension de sortie à 5V, même s'il y a des silences dans le signal d'entrée.

Simulations (LT-Spice)

Il est possible de réaliser une simulation du montage avec le logiciel d’électronique LT-Spice utilisé dans la partie précédente.

Boîtier de protection

A l'aide d'un générateur de boite en ligne (Makercase), on modélise une boite hexagonale en lien avec le logo de l'ESDM :

Les paramètres sont les suivants :

Sides : 6

Inside Diameter : 200mm

Inside Height : 50mm

Le fichier de la boite est le suivant : box_1.svg.zip

Programme Python sur Raspberry Pi

Le programme python sur Raspberry Pi s'inspire du programme développé dans le projet “Juke-box”.

A faire ...

Programme Python en utilisant une carte Arduino

A faire ...

Application : Rendre la sonnerie aléatoire - Projet "Hacking Sonnerie"

Principe de fonctionnement d’une association de HP sur une ligne 100V

La sonnerie du lycée s’insère dans le cadre d’une sonorisation sur une zone de diffusion large telle que salle de spectacle, kermesse, hypermarché, lieu de culte ou une gare. Dans ces environnements, il est nécessaire de tirer des câbles de grande longueur entre le (ou les) amplificateurs Basses Fréquences et les Hauts Parleurs répartis sur la zone à couvrir. Une documentation complète du principe de fonctionnement est accessible sur ce lien :

http://www.sonelec-musique.com/electronique_bases_association_hp_100v.html

Câblage audio

Schéma du montage

Programme Arduino 1 : Détection digitale

Le programme est téléchargeable sur ce lien: Sonnerie_Aleatoire_WT2003S_8.ino

#include "WT2003S_Player.h"
#ifdef __AVR__
#include <SoftwareSerial.h>
SoftwareSerial SSerial(5, 6); // RX, TX
#define COMSerial SSerial
#define ShowSerial Serial
WT2003S<SoftwareSerial> Mp3Player;
#endif
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define COMSerial Serial1
#define ShowSerial SerialUSB
WT2003S<Uart> Mp3Player;
#endif
#ifdef ARDUINO_ARCH_STM32F4
#define COMSerial Serial
#define ShowSerial SerialUSB
WT2003S<HardwareSerial> Mp3Player;
#endif
uint8_t vol = 10;
uint32_t spi_flash_songs = 0;
uint32_t sd_songs = 0;
STROAGE workdisk = SD;
struct Play_history {
uint8_t disk;
uint16_t index;
char name[8];
}* SPISong, *SDSong;
//////////////////////////////////////////////// mes variables globales et définitions /////////////////
#define BOUTON 2
#define ENTREE_DETECTEUR_SIGNAL A0
#define SEUIL_DETECTION 300 // déclenchement du son si l'entrée A0 > 0,5V soit une valeur de 1023/10 ~ 100
uint8_t status;
int entreeDetecteur =0;
// Defining some status codes from the WT2003S
#define STATUS_PLAY 0x01
#define STATUS_STOP 0x02
#define STATUS_PAUSE 0x03
//////////////////////////////////////////
/////////////////////////////// Méthodes utilisées dans le setup() et le loop()
void readSongName(struct Play_history* ph, uint32_t num, STROAGE disk) {
Mp3Player.volume(0);
delay(100);
switch (disk) {
case SPIFLASH:
Mp3Player.playSPIFlashSong(0x0001);
break;
case SD:
Mp3Player.playSDRootSong(0x0001);
break;
case UDISK:
Mp3Player.playUDiskRootSong(0x0001);
break;
}
ShowSerial.println("2...");
for (int i = 0; i < num ; i++) {
delay(300);
ph[i].disk = disk;
ph[i].index = Mp3Player.getTracks();
Mp3Player.getSongName(ph[i].name);
Mp3Player.next();
}
ShowSerial.println("4...");
Mp3Player.pause_or_play();
Mp3Player.volume(14);
delay(100);
}
void getAllSong() {
uint8_t diskstatus = Mp3Player.getDiskStatus();
ShowSerial.println(diskstatus);
spi_flash_songs = Mp3Player.getSPIFlashMp3FileNumber();
ShowSerial.print("SPIFlash:");
ShowSerial.println(spi_flash_songs);
if (spi_flash_songs > 0) {
SPISong = (struct Play_history*)malloc((spi_flash_songs + 1) * sizeof(struct Play_history));
readSongName(SPISong, spi_flash_songs, SPIFLASH);
}
if (diskstatus && 0x02) { // have SD
sd_songs = Mp3Player.getSDMp3FileNumber();
ShowSerial.print("SD:");
ShowSerial.println(sd_songs);
if (sd_songs > 0) {
SDSong = (struct Play_history*)malloc((sd_songs + 1) * sizeof(struct Play_history));
ShowSerial.println("1...");
readSongName(SDSong, sd_songs, SD);
}
}
}
void printSongs() {
ShowSerial.print("-------------------");
ShowSerial.print("index");
ShowSerial.print("<-------->");
ShowSerial.print("name");
ShowSerial.print("-------------------");
ShowSerial.println();
ShowSerial.println("-------------------spi flash-------------------------------");
for (int i = 0 ; i < spi_flash_songs; i++) {
ShowSerial.print("-------------------");
ShowSerial.print(SPISong[i].index);
ShowSerial.print("<-------->");
ShowSerial.print(SPISong[i].name);
ShowSerial.print("-------------------");
ShowSerial.println();
}
ShowSerial.println("-------------------sd card-------------------------------");
for (int i = 0 ; i < sd_songs; i++) {
ShowSerial.print("-------------------");
ShowSerial.print(SDSong[i].index);
ShowSerial.print("<-------->");
ShowSerial.print(SDSong[i].name);
ShowSerial.print("-------------------");
ShowSerial.println();
}
}
void printMenu(void) {
ShowSerial.println("MP3 Command List:");
ShowSerial.println("-----------------");
ShowSerial.println("'+' or '-' : raise/lower volume");
ShowSerial.println("'1' ~ '9' : select a song");
ShowSerial.println("'n' : next song");
ShowSerial.println("'s' : switch play disk, spi flash");
ShowSerial.println("'p' : play or pause");
ShowSerial.println("'w' : set playmode single no loop");
ShowSerial.println("'x' : set playmode single loop");
ShowSerial.println("'y' : set playmode all loop");
ShowSerial.println("'z' : set playmode random");
ShowSerial.println("'c' : Copy mp3 to SPIFlash");
ShowSerial.println(" (Yes, this really does go by copy order.)");
ShowSerial.println();
ShowSerial.println("Any other key to show this menu");
ShowSerial.println();
}
void audio(int cmd) {
ShowSerial.print("play:");
if (workdisk == SD) {
Mp3Player.playSDRootSong(cmd);
ShowSerial.print("Son joué : ");
ShowSerial.println(SDSong[cmd - '0'].name);
}
if (workdisk == SPIFLASH) {
Mp3Player.playSPIFlashSong(cmd - '0' - 1);
ShowSerial.print(cmd + ": ");
ShowSerial.print(SPISong[cmd - '0'].name);
}
ShowSerial.println();
}
void afficheSerialSon(int i) {
ShowSerial.print("-------------------");
ShowSerial.print(SPISong[i].index);
ShowSerial.print("<-------->");
ShowSerial.print(SPISong[i].name);
ShowSerial.print("-------------------");
ShowSerial.println();
}
/////////////////////////////////////////////////////////////////////// setup ///////////////////////
void setup() {
while (!ShowSerial);
ShowSerial.begin(9600);
COMSerial.begin(9600);
ShowSerial.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++");
Mp3Player.init(COMSerial);
ShowSerial.println("0...");
getAllSong();
printMenu();
printSongs();
/// volume au max
Mp3Player.volume(32);
// pin du bouton
pinMode(BOUTON, INPUT);
}
///////////////////////////////////////////// Loop ///////////////////////////////////
void loop() {
// tester le statut du lecteur : (1) est en train de jouer, (2): stop, (3): en pause
status = Mp3Player.getStatus();
entreeDetecteur = analogRead(ENTREE_DETECTEUR_SIGNAL);
if ( entreeDetecteur > SEUIL_DETECTION && (status == STATUS_STOP || status == STATUS_PAUSE)) { // si la tension en A0 est supéreure au seuil ET que le son ne joue pas 0x02:stop, 0x03: pause
// debug
ShowSerial.print("ENTREE_DETECTEUR_SIGNAL (A0) : ");
ShowSerial.println(entreeDetecteur);
digitalWrite(13, HIGH); // allumer la led LEDBUILTIN
// sélection aléatoire de l'indice de la musique
byte indexMusic = floor(random(0, sd_songs));
// affiche les caractéristiques de la musique
//afficheSerialSon(indexMusic);
ShowSerial.print("indice musique : ");
ShowSerial.println(indexMusic);
// joue la musique
Mp3Player.playMode(SINGLE_CYCLE);// joue la même musique en boucle
audio(indexMusic); // lance le son
}
else if (entreeDetecteur < SEUIL_DETECTION && status == STATUS_PLAY) { // OU si la tension en A0 est inférieure au seuil ET que le son joue : on l'arrête
// si le bouton est relâché et que le son joue : on l'arrête
digitalWrite(13, LOW);
//Mp3Player.stopPlaying(); // avec la librairie Sparkfun
Mp3Player.pause_or_play();
}
}

Programme Arduino 2 : Détection analogique

Le programme est téléchargeable sur ce lien: sonnerie_aleatoire_wt2003s_9_lecture_analog.ino.zip

///////// MOdule MP3 ///////////////////////////
#include "WT2003S_Player.h"
#ifdef __AVR__
#include <SoftwareSerial.h>
SoftwareSerial SSerial(5, 6); // 5-RX, 6-TX
#define COMSerial SSerial
#define ShowSerial Serial
WT2003S<SoftwareSerial> Mp3Player;
#endif
#ifdef ARDUINO_SAMD_VARIANT_COMPLIANCE
#define COMSerial Serial1
#define ShowSerial SerialUSB
WT2003S<Uart> Mp3Player;
#endif
#ifdef ARDUINO_ARCH_STM32F4
#define COMSerial Serial
#define ShowSerial SerialUSB
WT2003S<HardwareSerial> Mp3Player;
#endif
uint8_t vol = 10;
uint32_t spi_flash_songs = 0;
uint32_t sd_songs = 0;
STROAGE workdisk = SD;
struct Play_history {
uint8_t disk;
uint16_t index;
char name[8];
} *SPISong, *SDSong;
//////////////////////////////////////////////// mes variables globales et définitions /////////////////
#define BOUTON 2
#define ENTREE_SIGNAL_DETECTION 4 // slot D3 (fil blanc)
#define LED 7
uint8_t status;
boolean etat_entree_signal_ou_bouton = false;
boolean etat_bouton = false;
// entrée analogique
#define ENTREE_DETECTEUR_SIGNAL A1 ////////// Système de mesure du signal venant d
#define SEUIL_DETECTION 100 // déclenchement du son si l'entrée A1 > 5/1023*SEUIL_DETECTION V soit une valeur de 5/1023*100 = 0,488 V
int entreeDetecteur = 0; // variable de mémorisation du signal d'entrée A0
// Defining some status codes from the WT2003S
#define STATUS_PLAY 0x01
#define STATUS_STOP 0x02
#define STATUS_PAUSE 0x03
//////////////////////////////////////////
/////////////////////////////// Méthodes utilisées dans le setup() et le loop()
void readSongName(struct Play_history* ph, uint32_t num, STROAGE disk) {
Mp3Player.volume(0);
delay(100);
switch (disk) {
case SPIFLASH:
Mp3Player.playSPIFlashSong(0x0001);
break;
case SD:
Mp3Player.playSDRootSong(0x0001);
break;
case UDISK:
Mp3Player.playUDiskRootSong(0x0001);
break;
}
ShowSerial.println("2...");
for (int i = 0; i < num ; i++) {
delay(300);
ph[i].disk = disk;
ph[i].index = Mp3Player.getTracks();
Mp3Player.getSongName(ph[i].name);
Mp3Player.next();
}
ShowSerial.println("4...");
Mp3Player.pause_or_play();
Mp3Player.volume(14);
delay(100);
}
void getAllSong() {
uint8_t diskstatus = Mp3Player.getDiskStatus();
ShowSerial.println(diskstatus);
spi_flash_songs = Mp3Player.getSPIFlashMp3FileNumber();
ShowSerial.print("SPIFlash:");
ShowSerial.println(spi_flash_songs);
if (spi_flash_songs > 0) {
SPISong = (struct Play_history*)malloc((spi_flash_songs + 1) * sizeof(struct Play_history));
readSongName(SPISong, spi_flash_songs, SPIFLASH);
}
if (diskstatus && 0x02) { // have SD
sd_songs = Mp3Player.getSDMp3FileNumber();
ShowSerial.print("SD:");
ShowSerial.println(sd_songs);
if (sd_songs > 0) {
SDSong = (struct Play_history*)malloc((sd_songs + 1) * sizeof(struct Play_history));
ShowSerial.println("1...");
readSongName(SDSong, sd_songs, SD);
}
}
}
void printSongs() {
ShowSerial.print("-------------------");
ShowSerial.print("index");
ShowSerial.print("<-------->");
ShowSerial.print("name");
ShowSerial.print("-------------------");
ShowSerial.println();
ShowSerial.println("-------------------spi flash-------------------------------");
if (spi_flash_songs > 0) {
for (int i = 0 ; i < spi_flash_songs; i++) {
ShowSerial.print("-------------------");
ShowSerial.print(SPISong[i].index);
ShowSerial.print("<-------->");
ShowSerial.print(SPISong[i].name);
ShowSerial.print("-------------------");
ShowSerial.println();
}
}
else {
ShowSerial.println("Aucune Chanson dans spi flash");
}
ShowSerial.println("-------------------sd card-------------------------------");
for (int i = 0 ; i < sd_songs; i++) {
ShowSerial.print("-------------------");
ShowSerial.print(SDSong[i].index);
ShowSerial.print("<-------->");
ShowSerial.print(SDSong[i].name);
ShowSerial.print("-------------------");
ShowSerial.println();
}
}
void printMenu(void) {
ShowSerial.println("MP3 Command List:");
ShowSerial.println("-----------------");
ShowSerial.println("'+' or '-' : raise/lower volume");
ShowSerial.println("'1' ~ '9' : select a song");
ShowSerial.println("'n' : next song");
ShowSerial.println("'s' : switch play disk, spi flash");
ShowSerial.println("'p' : play or pause");
ShowSerial.println("'w' : set playmode single no loop");
ShowSerial.println("'x' : set playmode single loop");
ShowSerial.println("'y' : set playmode all loop");
ShowSerial.println("'z' : set playmode random");
ShowSerial.println("'c' : Copy mp3 to SPIFlash");
ShowSerial.println(" (Yes, this really does go by copy order.)");
ShowSerial.println();
ShowSerial.println("Any other key to show this menu");
ShowSerial.println();
}
void audio(int cmd) {
ShowSerial.println("PLAY");
if (workdisk == SD) {
Mp3Player.playSDRootSong(cmd);
ShowSerial.print("Son joué : ");
ShowSerial.print("N°=");
ShowSerial.print(cmd);
ShowSerial.print(" ; name : ");
ShowSerial.println(SDSong[cmd - '0'].name);
}
if (workdisk == SPIFLASH) {
Mp3Player.playSPIFlashSong(cmd - '0' - 1);
ShowSerial.print(cmd + ": ");
ShowSerial.print(SPISong[cmd - '0'].name);
}
ShowSerial.println();
}
void afficheSerialSon(int i) {
ShowSerial.print("-------------------");
ShowSerial.print(SPISong[i].index);
ShowSerial.print("<-------->");
ShowSerial.print(SPISong[i].name);
ShowSerial.print("-------------------");
ShowSerial.println();
}
/////////////////////////////////////////////////////////////////////// setup ///////////////////////
void setup() {
while (!ShowSerial);
ShowSerial.begin(9600);
COMSerial.begin(9600);
ShowSerial.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++");
Mp3Player.init(COMSerial);
ShowSerial.println("0...");
getAllSong();
printMenu();
printSongs();
/// volume au max
Mp3Player.volume(32);
// pin du bouton
pinMode(BOUTON, INPUT);
pinMode(ENTREE_SIGNAL_DETECTION, INPUT);
pinMode(LED, OUTPUT);
}
///////////////////////////////////////////// Loop ///////////////////////////////////
void loop() {
// tester le statut du lecteur : (1) est en train de jouer, (2): stop, (3): en pause
status = Mp3Player.getStatus();
// lecture entrée analogique A0 -> signal de sortie du détecteur
entreeDetecteur = analogRead(ENTREE_DETECTEUR_SIGNAL);
etat_bouton = digitalRead(BOUTON);
etat_entree_signal_ou_bouton = (etat_bouton == HIGH || entreeDetecteur > SEUIL_DETECTION);
// debug
//ShowSerial.print("etat_entree_signal_ou_bouton=");
//ShowSerial.println(etat_entree_signal_ou_bouton);
if (etat_entree_signal_ou_bouton == true && (status == STATUS_STOP || status == STATUS_PAUSE) ) {
// debug
//ShowSerial.print("entrée Analog = ");
//ShowSerial.println(etat_entree_signal_ou_bouton);
// debug
//ShowSerial.println("lance musique aléatoire");
// debug
ShowSerial.print("entrée Analog = ");
ShowSerial.println(entreeDetecteur);
ShowSerial.print("entrée BOUTON = ");
ShowSerial.println(etat_bouton);
// si bouton appuyé ET que le son ne joue pas 0x02:stop, 0x03: pause
digitalWrite(LED, HIGH); // allumer la led
// sélection aléatoire de l'indice de la musique
byte indexMusic = floor(random(0, sd_songs));
// debug
// affiche les caractéristiques de la musique
//ShowSerial.print("indice musique : ");
//ShowSerial.println(indexMusic);
// joue la musique
Mp3Player.playMode(SINGLE_CYCLE);// joue la même musique en boucle
audio(indexMusic); // lance le son
}
else if (etat_entree_signal_ou_bouton == false && status == STATUS_PLAY) {
// si le bouton est relâché et que le son joue : on l'arrête
digitalWrite(LED, LOW);
//Mp3Player.stopPlaying();
Mp3Player.pause_or_play();
}
// debug
//delay(300);
}