sw/boitarire_sw/boitarire_sw.ino

@@ -23,8 +23,8 @@
 
 // Defines - Macros - Constants
 
-//#define SENSOR_INCLINATION
-#define SENSOR_ACCELEROMETER
+#define SENSOR_INCLINATION
+//#define SENSOR_ACCELEROMETER
 //#define SENSOR_TOUCH_SENSOR1
 //#define SENSOR_TOUCH_SENSOR2
 

sw/scenarios/README.md

+# Programmation de la Boitearire
+La Boitearire fonctionne grâce à un micro-contrôleur qui analyse les movements et actions perçu par des capteurs électronique. Il est nécessaire de le programmer afin qu'il puisse traiter les données fournit par ces capteur afin de jouer le bon son au bon moment.   
+
+Nous avons donc conçu plusieurs scénarios intégrant un ou plusieurs capteur afin de vous montrer comment programmer le micro-contrôleur et exploiter les capteurs associés.   
+Des explications sont ajouté dans le code de chaque scénario afin de vous aider à mieux comprendre ce que fait chaque programme.
+
+
+## Pré-requis à la programmation
+Il est nécessaire de respecter quelques pré-requis afin de pouvoir programmer le micro-contrôleur.
+
+1. Installer le logiciel [Arduino IDE](https://www.arduino.cc/en/software) dont l'installateur est disponible [ici](https://downloads.arduino.cc/arduino-ide/arduino-ide_2.1.0_Windows_64bit.exe).
+2. Installer les pilotes logiciel pour la carte Arduino Nano v3.   
+   Ces derniers s'installent automatiquement lors du lancement du logiciel _Arduino IDE_.
+3. Configurer la carte sur le logiciel _Arduino IDE_ :
+   - Barre des menus > Outils > Cartes > Arduino AVR Boards > Arduino nano
+   - Barre des menus > Outils > Port > _COMx_
+   - Barre des menus > Outils > Processeur > ATmega328P (Old bootloader)
+
+## Ajout de son sur le module lecteur MP3
+Par défaut, les modules MP3 sont livrés avec 4 courtes piste audio. On peut cependant vouloir changer ou ajouter de nouvelles pistes audio. Il suffit alors de suivre les instructions ci-dessous.
+
+**Attention:** Le muodule MP3 ne dispose que de 4MB de mémoire pour les pistes audio.
+
+1. Connecter le module MP3 à l'ordinateur via un câble micro-usb
+2. Ouvrir l'explorateur de fichier et se rendre dans le périphérique nouvellement monté
+3. Ajouter / supprimer des pistes audio
+
+**Attention:** Le format de la piste audio doit être un **MP3** (.mp3) et le nom du fichier doit être compris entre **00001.mp3** et **00255.mp3**
+
+La documentation du module MP3 est disponible [ici](https://github.com/smoluks/DY-SV17F/blob/master/DY-SV17F%20module%20functions%20introduction.pdf) (en anglais).
+
+## Scénario 1 : Capteur d'inclinaison
+Afin de se rapprocher au plus près du fonctionnement d'une _réelle_ boite à meuh ce scénario utilise un capteur d'inclinaison.   
+Lorsque l'on retourne la Boitearire, une petite bille métallique intégrée dans le capteur vient faire contact entre les deux bornes de ce dernier. On se retrouve donc avec un interrupteur fermé, ce qui déclenche la lecture d'une piste audio.
+
+Pour utiliser ce scénario, ouvrez le programme `scenario1_capteur_inclinaison` puis lancez le téléversement sur votre micro-contrôleur.
+
+Ps : le capteur d'inclinaison ressemble à ça.   
+![Capteur inclinaison](images/capteur_inclinaison.jpg)
+
+## Scénario 2 : Accéléromètre
+Avoir un comportement proche d'une réelle boite à meuh est intéressant, certes, mais nous pouvons faire des choses bien plus complexes avec la Boitearire !   
+La carte est en effet équipée d'un module accéléromètre, un composant capable de détecter les changements d'accélération selon 3 axes et de les mesurer. Nous pouvons donc déclencher la lecture d'une piste lorsque un mouvement est réalisé et non plus seulement lorsque la carte est retournée. 
+
+Pour utiliser ce scénario, ouvrez le programme `scenario2_accelerometre` puis lancez le téléversement sur votre micro-contrôleur.
+
+Par défaut le code est configuré pour ne détecter que les rotation sur trois axes.  
+Il est cependant possible de configurer le code pour qu'une piste soit jouée lorsqu'une accélération quelconque est appliqué à la carte.  
+Pour cela, commenter la ligne suivante dans le code du scénario : 
+```c
+...
+
+// Définition des constantes de paramétrage
+// #define ACCEL_ROTATION_DETECT     // Activation de la lecture sur rotation de la boitearire et non sur mouvement seul
+#define DELAY_MP3_RESET     100   // Temps d'activation pour réinitalisation du module MP3
+...
+```
+
+Ps : l'accéléromètre ressemble à ça :  
+![Capteur inclinaison](images/accelerometre.jpg)
\ No newline at end of file

sw/scenarios/scenario1_capteur_inclinaison/scenario1_capteur_inclinaison.ino

+/*
+  Boitarire Scénario 1 : Catpeur d'inclinaison
+
+  Joue une piste audio grâce à un module MP3 lorsque activé par un capteur : 
+    - capteur d'inclinaison
+
+  créé le  25 nov 2021
+  par Florian Savard
+
+  Cet exemple de code est publié sous domaine pulique.
+
+  https://code.electrolab.fr/Flax/boitarire
+*/
+
+// Définition des constantes matérielles
+#define PIN_SENSOR_POSITION 9     // Entrée capteur inclinaison               - Entrée, état bas = boite a rire retournée
+#define PIN_GROUND_SWITCH   7     // Sortie de commande du module MP3         - Sortie, état haut = jouer une piste
+#define PIN_BUSY            2     // Entrée d'état du module MP3              - Entrée, état bas = le module est occupé
+
+// Définition des constantes de paramétrage
+#define DELAY_MP3_RESET     100   // Temps d'activation pour réinitalisation du module MP3
+#define DEBOUNCE_DELAY      200   // Délais anti-rebond pour le catpeur d'inclinaison
+#define PLAYLIST_LENGTH     4     // Nombre de pistes audio dans le module MP3
+
+// Typedefs : définition de types personnalisés en C
+
+// Machine à état principale : ce qui fait les actions
+typedef enum 
+{
+  // Initialisation
+  STM_INIT,
+  // Attente d'un signale provenant du capteur d'inclinaison
+  STM_IDLE,
+  // Après reception d'un signal, lecture d'une piste audio
+  STM_PLAY,
+  // Délais d'attente post-activation du module MP3
+  STM_BLANK,
+  // Optionnel, réinitalisation du modulke MP3
+  STM_MP3_RESET,
+} tStateMachine;
+
+// Machine à état anti-rebond : évite les déclanchement intempestif du module MP3
+typedef enum
+{
+  STM_DEBOUNCE_IDLE_0,
+  STM_DEBOUNCE_IDLE_1,
+  STM_DEBOUNCE_DETECT_0,
+  STM_DEBOUNCE_DETECT_1,
+  STM_DEBOUNCE_DEBOUNCE_0,
+  STM_DEBOUNCE_DEBOUNCE_1,
+} tStateMachineDebounce;
+
+typedef struct 
+{
+  uint8_t song_index_u8;       // Index de la piste audio dans le mobule MP3 /!\ On compte à partir de 0
+  uint8_t cycles_number_u8;    // Nombre de fois que la piste doit être jouée avant de passer à la suivante
+  uint16_t blank_delay_u16;    // Temps d'attente avant nouvelle lecture (ms)
+} tSongItem;
+
+// Définition des variables globales
+
+/* Table d'indifférence pour les cycles de chansons
+ * Contient les index des chansons à jouer et le nombre de fois que chacune doit être jouée.
+ * Contient les couples {index de la chanson dans la mémoire de l'appareil MP3, nombre de fois que la chanson doit être jouée, temps d'attente},
+ * Les cycles de la liste de lecture vont du premier au dernier élément et les boucles.
+ * N'oubliez pas de mettre à jour la définition de PLAYLIST_LENGTH.
+ */
+const tSongItem cPlaylistIndif_TA[PLAYLIST_LENGTH] =
+{
+  {0, 2, 1000}, 
+  {1, 2, 1000},
+};
+
+
+// Définition des variables locales
+
+String inputString = "";          // Une chaîne de caractères comprenant les données entrantes
+bool stringComplete = false;      // Booléen indiquant quand la chaîne de cractères est complète
+
+unsigned long debounce_delay;     // Temps nécessaire pour l'anti*rebond
+int input_position_sensor;        // état du capteur de position
+unsigned long play_blank_delay, play_blank_delay_threshold, mp3_reset_delay; // Différents délais liés au module MP3
+unsigned long millis_temp;        // Stockage de compteur de millisecondes
+
+uint8_t song_cycles_cnt_u8;       // Compteur du nombre de fois qu'une piste audio à été jouée
+uint8_t song_playing_current_u8;  // Index de la piste audio actuellement jouée
+
+// Enregistrement des machines à état
+tStateMachine stmState;
+tStateMachineDebounce stmDebounceState;
+
+// Enregistrement des prototypes de fonction
+void ReadPlayState (void);
+void WritePlay (void);
+void WritePlaySong (uint16_t index);
+uint8_t CrcCalculate (uint8_t *buff, uint8_t size);
+
+// Fonction d'initialisation du mirco-contrôleur
+void setup() {
+  // Initialisation du port série: permets la configuration du module MP3
+  Serial.begin(9600);
+  // Réservation de 200 octets pour la chaîne de caractères:
+  inputString.reserve(200);
+
+  // Définition du mode pour l'entrée numérique du capteur d'inclinaison
+  pinMode(PIN_SENSOR_POSITION, INPUT_PULLUP);
+
+  // Définition du mode pour la LED intrégrée à la carte arduino nano (débug)
+  pinMode(LED_BUILTIN, OUTPUT);
+
+  // Définition du mode pour la commande de lecture du module MP3
+  pinMode(PIN_GROUND_SWITCH, OUTPUT);
+
+  // Définition du mode pour l'entrée d'état du module MP3
+  pinMode(PIN_BUSY, INPUT);
+
+  // Initialisation des variables locales
+  play_blank_delay = 0;
+  mp3_reset_delay = 0;
+  stmState = STM_INIT;
+  stmDebounceState = STM_DEBOUNCE_IDLE_0;
+  debounce_delay = 0;
+  input_position_sensor = LOW;
+  song_cycles_cnt_u8 = 0;
+  song_playing_current_u8 = 0;
+
+  // Ouverture de la connexion série au module MP3
+  digitalWrite(PIN_GROUND_SWITCH, HIGH);
+
+}
+
+void loop() {
+  // print the string when a newline arrives: for debug purposes only
+  if (stringComplete) {
+    Serial.println(inputString);
+
+    switch (inputString[0])
+    {
+      case 0x30:
+        // Play first song in the device
+        WritePlaySong(1);
+        break;
+      case 0x31:
+        // Play second song in the device
+        WritePlaySong(2);
+        break;
+      default:
+        break;
+    }
+    
+    // clear the string:
+    inputString = "";
+    stringComplete = false;
+  }
+
+  // Lecture de l'état du capteur d'inclinaison
+  input_position_sensor = digitalRead(PIN_SENSOR_POSITION);
+
+  // Exploitation de l'anti-rebond pour le capteur d'inclinaison
+  //-----------------------------------
+  switch (stmDebounceState)
+  {
+    case STM_DEBOUNCE_IDLE_0:
+      if (input_position_sensor == HIGH)
+      {
+        stmDebounceState = STM_DEBOUNCE_DETECT_1;
+        debounce_delay = millis();
+      }
+    break;
+
+    case STM_DEBOUNCE_IDLE_1:
+      if (input_position_sensor == LOW)
+      {
+        stmDebounceState = STM_DEBOUNCE_DETECT_0;
+        debounce_delay = millis();
+      }
+    break;
+
+    case STM_DEBOUNCE_DETECT_0:
+      millis_temp = millis();
+      if (input_position_sensor == HIGH)
+      {
+        stmDebounceState = STM_DEBOUNCE_IDLE_1;
+      }
+      else if ((millis_temp >= debounce_delay) && ((millis_temp - debounce_delay) > DEBOUNCE_DELAY))
+      {
+        stmDebounceState = STM_DEBOUNCE_DEBOUNCE_0;
+      }
+      else if (millis_temp < debounce_delay)
+      { // Overflow protection for uptime of several weeks or more.
+        debounce_delay = 0;
+      }
+    break;
+
+    case STM_DEBOUNCE_DETECT_1:
+      millis_temp = millis();
+      if (input_position_sensor == LOW)
+      {
+        stmDebounceState = STM_DEBOUNCE_IDLE_0;
+      }
+      else if ((millis_temp >= debounce_delay) && ((millis_temp - debounce_delay) > DEBOUNCE_DELAY))
+      {
+        stmDebounceState = STM_DEBOUNCE_DEBOUNCE_1;
+      }
+      else if (millis_temp < debounce_delay)
+      { // Overflow protection for uptime of several weeks or more.
+        debounce_delay = 0;
+      }
+    break;
+
+    case STM_DEBOUNCE_DEBOUNCE_0:
+      stmDebounceState = STM_DEBOUNCE_IDLE_0;
+      //digitalWrite(LED_BUILTIN, LOW); // DEBUG
+    break;
+
+    case STM_DEBOUNCE_DEBOUNCE_1:
+      stmDebounceState = STM_DEBOUNCE_IDLE_1;
+      //digitalWrite(LED_BUILTIN, HIGH); // DEBUG
+    break;
+
+    default:
+    break;
+  }
+
+  // Machine à état principale : on fait des trucs !
+  //-------------------
+  switch (stmState)
+  {
+    // Initialisation pas encore utiliée, prévu pour utilisation future
+    case STM_INIT:
+      stmState = STM_IDLE;            // Passage à l'état STM_IDLE
+    break;
+
+    case STM_IDLE:
+      //digitalWrite(LED_BUILTIN, LOW); // DEBUG
+      if (stmDebounceState == STM_DEBOUNCE_DEBOUNCE_1)
+      {
+        stmState = STM_PLAY;          // Passage à l'état STM_PLAY
+      }
+    break;
+
+    case STM_PLAY:
+      WritePlaySong(cPlaylistIndif_TA[song_playing_current_u8].song_index_u8 + 1U);            // Lecture de la piste actuellement selectionnée (exemple: index à 0 + 1 = piste 1)
+      //digitalWrite(LED_BUILTIN, HIGH); // DEBUG
+      play_blank_delay_threshold = cPlaylistIndif_TA[song_playing_current_u8].blank_delay_u16; // Chargement du temps d'attente pour le rejeux de la piste
+      song_cycles_cnt_u8++;                                                                    // Incrémentation du compteur de lecture de piste
+      
+      if (song_cycles_cnt_u8 >= cPlaylistIndif_TA[song_playing_current_u8].cycles_number_u8)
+      { // Vérification de si le compteur de lecture dépasse la valeur maximale définie plus haut
+        song_cycles_cnt_u8 = 0;       // Réinitialisation du compteur de lecture
+        song_playing_current_u8++;    // Passage à la piste audio suivante (index de piste = index courrant + 1)
+      }
+
+      if (song_playing_current_u8 >= PLAYLIST_LENGTH)
+      { // Vérification de si l'index de piste dépasse le nombre maximale de piste sur le module MP3
+        song_playing_current_u8 = 0;  // Réinitialisation de l'index de piste audio 
+      }
+       
+      play_blank_delay = millis();    // Enregistrement de la valeur courante d'attente pour la prochaine lecture
+      stmState = STM_BLANK;           // Passage à l'état STM_BLANK
+    break;
+
+    case STM_BLANK:
+      millis_temp = millis();         // Obtention du temps actuel en millisecondes
+
+      if ((millis_temp >= play_blank_delay) && ((millis_temp - play_blank_delay) > play_blank_delay_threshold))
+      { // Comparaison entre le temps actuelle et la valeur d'attente enregistrée
+
+        stmState = STM_IDLE;         // Passage à l'état STM_IDLE
+      }
+      else if (millis_temp < play_blank_delay)
+      { // Overflow protection for uptime of several weeks or more.
+        play_blank_delay = 0;
+      }
+    break;
+
+    case STM_MP3_RESET:
+      millis_temp = millis();
+      //digitalWrite(LED_BUILTIN, LOW); // DEBUG
+      if ((millis_temp >= mp3_reset_delay) && ((millis_temp - mp3_reset_delay) > DELAY_MP3_RESET))
+      {
+        stmState = STM_IDLE;
+        digitalWrite(PIN_GROUND_SWITCH, HIGH);
+      }
+      else if (millis_temp < mp3_reset_delay)
+      { // Overflow protection for uptime of several weeks or more.
+        mp3_reset_delay = 0;
+      }
+    break;
+
+    default:
+      stmState = STM_INIT;
+    break;
+  }
+
+}
+
+/*
+  SerialEvent est exécuté chaque fois qu'une nouvelle donnée arrive dans le RX série matériel. Cette routine
+  Cette routine est exécutée entre chaque exécution de loop(), donc l'utilisation d'un délai dans la boucle peut
+  retarder la réponse. Plusieurs octets de données peuvent être disponibles.
+*/
+void serialEvent() {
+  while (Serial.available()) {
+    // Obtention du nouvel octet:
+    char inChar = (char)Serial.read();
+    // ajout de l'octet  à la chaîne de caractère inputString:
+    inputString += inChar;
+    // Si le cacratère contenu dans l'octet est un retour à la ligne, définir marquer la ligne comme complète
+    if (inChar == '\n') {
+      stringComplete = true;
+    }
+  }
+}
+
+void ReadPlayState (void)
+{
+  // Commande pour obtenir l'état du module MP3 (voir doc PDF)
+  Serial.write(170); // 0xAA
+  Serial.write(1);   // 0x01
+  Serial.write(0);   // 0x00
+  Serial.write(171); // 0xAB
+}
+
+void WritePlay (void)
+{
+  // Commande pour demander  jouer une piste 
+  Serial.write(170); // 0xAA
+  Serial.write(2);   // 0x02
+  Serial.write(0);   // 0x00
+  Serial.write(172); // 0xAC
+}
+
+void WritePlaySong (uint16_t index)
+{
+  // Commande pour demander la lecture d'une piste spécifique
+  uint8_t buffer_u8A[5];
+  buffer_u8A[0] = 0xAA;
+  buffer_u8A[1] = 0x07;
+  buffer_u8A[2] = 0x02;
+  buffer_u8A[3] = (uint8_t)((index >> 8U) & (uint16_t)0x00FF);
+  buffer_u8A[4] = (uint8_t)(index & (uint16_t)0x00FF);
+  uint8_t crc_u8 = CrcCalculate(buffer_u8A, 5);
+  // Commande à proprement parler
+  Serial.write((int)buffer_u8A[0]); // 0xAA
+  Serial.write((int)buffer_u8A[1]); // 0x07
+  Serial.write((int)buffer_u8A[2]); // 0x02
+  Serial.write((int)buffer_u8A[3]); // Song number high byte
+  Serial.write((int)buffer_u8A[4]); // Song number low byte
+  Serial.write((int)crc_u8);        // CRC
+}
+
+uint8_t CrcCalculate (uint8_t *buff, uint8_t size)
+{
+  // Calcule du code correcteur d'erreur
+  uint16_t ret_u16 = 0;
+  uint8_t cnt_u8 = 0;
+
+  for (cnt_u8 = 0; cnt_u8 < size; cnt_u8++)
+  {
+    ret_u16 += *(buff + cnt_u8);
+  }
+
+  return ((uint8_t)(ret_u16 & (uint16_t)0x00FF));
+}
+

sw/scenarios/scenario2_accelerometre/scenario2_accelerometre.ino

+/*
+  Boitarire Scénario 1 : Accéléromètre
+
+  Joue une piste audio grâce à un module MP3 lorsque activé par un capteur : 
+    - un accéléromètre
+
+  créé le  25 nov 2021
+  par Florian Savard
+
+  Cet exemple de code est publié sous domaine pulique.
+
+  https://code.electrolab.fr/Flax/boitarire
+*/
+
+// Importation des bibliotèques 
+#include<Wire.h>
+
+
+// Définition des constantes matérielles
+#define PIN_GROUND_SWITCH   7     // Sortie de commande du module MP3         - Sortie, état haut = jouer une piste
+#define PIN_BUSY            2     // Entrée d'état du module MP3              - Entrée, état bas = le module est occupé
+
+// Définition des constantes de paramétrage
+#define ACCEL_ROTATION_DETECT     // Activation de la lecture sur rotation de la boitearire et non sur mouvement seul
+#define DELAY_MP3_RESET     100   // Temps d'activation pour réinitalisation du module MP3
+#define ACCEL_THRES_GYX     9999  // Seuil de détection pour l'axe X en acceleration
+#define ACCEL_THRES_GYY     9999  // Seuil de détection pour l'axe Y en acceleration
+#define ACCEL_THRES_GYZ     25000 // Seuil de détection pour l'axe Z en acceleration
+#define ACCEL_THRES_ROT     200   // Seuil de détection en rotation, pour pré-filtrage
+#define ACCEL_TRIG_ROT      2000  //  Seuil de détection en rotation
+#define PLAYLIST_LENGTH     4     // Nombre de pistes audio dans le module MP3
+
+// Typedefs : définition de types personnalisés en C
+
+// Machine à état principale : ce qui fait les actions
+typedef enum 
+{
+  // Initialisation
+  STM_INIT,
+  // Attente d'un signale provenant du capteur d'inclinaison
+  STM_IDLE,
+  // Après reception d'un signal, lecture d'une piste audio
+  STM_PLAY,
+  // Délais d'attente post-activation du module MP3
+  STM_BLANK,
+  // Optionnel, réinitalisation du modulke MP3
+  STM_MP3_RESET,
+} tStateMachine;
+
+typedef struct 
+{
+  uint8_t song_index_u8;       // Index de la piste audio dans le mobule MP3 /!\ On compte à partir de 0
+  uint8_t cycles_number_u8;    // Nombre de fois que la piste doit être jouée avant de passer à la suivante
+  uint16_t blank_delay_u16;    // Temps d'attente avant nouvelle lecture (ms)
+} tSongItem;
+
+/* Structure de calcul des mesures de l'accéléromètre
+ * Enregistre deux mesures, une valeur filtrée et une valeur intégrée. (Vive les Mathématiques !)
+ */
+typedef struct
+{
+  int16_t sample1_s16;
+  int16_t sample2_s16;
+  int16_t sample_filt_s16;
+  int16_t sample_int_s16;
+} tAccelSample;
+
+//  Structure représentant toutes les données de l'accéléromètre pour traitement.
+typedef struct
+{
+  tAccelSample AcX; // X linear axis
+  tAccelSample AcY; // Y linear axis
+  tAccelSample AcZ; // Z linear axis
+  tAccelSample GyX; // X rotational axis
+  tAccelSample GyY; // Y rotational axis
+  tAccelSample GyZ; // Z rotational axis
+} tAccelData;
+
+// Définition des variables globales
+
+/* Table d'indifférence pour les cycles de chansons
+ * Contient les index des chansons à jouer et le nombre de fois que chacune doit être jouée.
+ * Contient les couples {index de la chanson dans la mémoire de l'appareil MP3, nombre de fois que la chanson doit être jouée, temps d'attente},
+ * Les cycles de la liste de lecture vont du premier au dernier élément et les boucles.
+ * N'oubliez pas de mettre à jour la définition de PLAYLIST_LENGTH.
+ */
+const tSongItem cPlaylistIndif_TA[PLAYLIST_LENGTH] =
+{
+  {0, 2, 1000}, 
+  {1, 2, 1000},
+};
+
+// Définition des variables locales
+
+String inputString = "";          // Une chaîne de caractères comprenant les données entrantes
+bool stringComplete = false;      // Booléen indiquant quand la chaîne de cractères est complète
+
+unsigned long play_blank_delay, play_blank_delay_threshold, mp3_reset_delay; // Différents délais liés au module MP3
+unsigned long millis_temp;        // Stockage de compteur de millisecondes
+
+const int MPU=0x68;               // Adresse I2C en hexadecimale de l'accéléromètre
+int16_t Tmp;                      // Tampon de lecture I2C
+tAccelData AccelData_T;           // Structure de donnée pour l'accéléromètre
+bool accel_detect;                // Booléen indiquant si l'accéléromètre a détécté le mouvement attendu
+bool accel_detect_x, accel_detect_y, accel_detect_z; // Idem, mais par axe
+
+uint8_t song_cycles_cnt_u8;       // Compteur du nombre de fois qu'une piste audio à été jouée
+uint8_t song_playing_current_u8;  // Index de la piste audio actuellement jouée
+
+// Enregistrement des machines à état
+tStateMachine stmState;
+
+// Enregistrement des prototypes de fonction
+void ReadPlayState (void);
+void WritePlay (void);
+void WritePlaySong (uint16_t index);
+uint8_t CrcCalculate (uint8_t *buff, uint8_t size);
+
+// Fonction d'initialisation du mirco-contrôleur
+void setup() {
+  // Initialisation du port série: permets la configuration du module MP3
+  Serial.begin(9600);
+  // Réservation de 200 octets pour la chaîne de caractères:
+  inputString.reserve(200);
+
+  // Définition du mode pour la LED intrégrée à la carte arduino nano (débug)
+  pinMode(LED_BUILTIN, OUTPUT);
+
+  // Définition du mode pour la commande de lecture du module MP3
+  pinMode(PIN_GROUND_SWITCH, OUTPUT);
+
+  // Définition du mode pour l'entrée d'état du module MP3
+  pinMode(PIN_BUSY, INPUT);
+
+  // Initialisation des variables locales
+  play_blank_delay = 0;
+  mp3_reset_delay = 0;
+  stmState = STM_INIT;
+  song_cycles_cnt_u8 = 0;
+  song_playing_current_u8 = 0;
+
+  // Initialisation de l'accéléromètre
+  Wire.begin();
+  Wire.beginTransmission(MPU);
+  Wire.write(0x6B); 
+  Wire.write(0);    
+  Wire.endTransmission(true);
+
+  // Activation des filtres sur l'accéléromètre
+  Wire.beginTransmission(MPU);
+  Wire.write(0x1A); 
+  Wire.write(0x06);    
+  Wire.endTransmission(true);
+
+  accel_detect = false;
+
+  // Ouverture de la connexion série au module MP3
+  digitalWrite(PIN_GROUND_SWITCH, HIGH);
+}
+
+void loop() {
+  // print the string when a newline arrives: for debug purposes only
+  if (stringComplete) {
+    Serial.println(inputString);
+
+    switch (inputString[0])
+    {
+      case 0x30:
+        // Play first song in the device
+        WritePlaySong(1);
+        break;
+      case 0x31:
+        // Play second song in the device
+        WritePlaySong(2);
+        break;
+      default:
+        break;
+    }
+    
+    // clear the string:
+    inputString = "";
+    stringComplete = false;
+  }
+
+  // Communication avec l'accéléromètre : Demande de prise de mesure puis lecture successive des valeurs
+  Wire.beginTransmission(MPU);
+  Wire.write(0x3B);  
+  Wire.endTransmission(false);
+  Wire.requestFrom(MPU,14,true);  
+  AccelData_T.AcX.sample1_s16=Wire.read()<<8|Wire.read();   
+  AccelData_T.AcY.sample1_s16=Wire.read()<<8|Wire.read(); 
+  AccelData_T.AcZ.sample1_s16=Wire.read()<<8|Wire.read(); 
+  Tmp=Wire.read()<<8|Wire.read();  
+  AccelData_T.GyX.sample1_s16=Wire.read()<<8|Wire.read();   
+  AccelData_T.GyY.sample1_s16=Wire.read()<<8|Wire.read(); 
+  AccelData_T.GyZ.sample1_s16=Wire.read()<<8|Wire.read(); 
+
+  #ifdef ACCEL_ROTATION_DETECT
+  /*
+  * Détection de la rotation
+  * La détection est effectuée indépendamment sur chaque axe.
+  * Sur chaque axe, l'entrée Gy... est filtrée en passe-haut afin de filtrer le bruit de fond.
+  * Le filtre passe-haut est un filtre IIR standard du premier ordre avec alpha = 0,5.
+  * Si les données filtrées passe-haut atteignent le seuil ACCEL_THRES_ROT, ou si les données non filtrées atteignent 2^4 fois ACCEL_THRES_ROT, 
+  * les données sont alors considérées comme valides et intégrées.
+  * Une fois qu'elles sont valides, la mesure d'entrée est ajoutée aux données intégrées.
+  * Lorsque les données intégrées atteignent ACCEL_TRIG_ROT, un déclenchement est lancé sur cet axe.
+  * Un déclenchement se produit si l'un des trois axes est déclenché.
+  */
+
+  // Mangeons des mathématique : miam !
+  
+    // Traitement de l'axe X -----
+    // Filtre passe-bane pour GyX
+    AccelData_T.GyX.sample_filt_s16 = (AccelData_T.GyX.sample_filt_s16 + (AccelData_T.GyX.sample1_s16 - AccelData_T.GyX.sample2_s16)) >> 1;
+    if ((AccelData_T.GyX.sample1_s16 > (ACCEL_THRES_ROT << 4)) ||
+        (AccelData_T.GyX.sample1_s16 < -(ACCEL_THRES_ROT << 4)) ||
+        (AccelData_T.GyX.sample_filt_s16 > ACCEL_THRES_ROT) || 
+        (AccelData_T.GyX.sample_filt_s16 < -(ACCEL_THRES_ROT))) // Détection du passage de seuil
+    {
+      AccelData_T.GyX.sample_int_s16 += (AccelData_T.GyX.sample1_s16 >> 9); // Integration
+    }
+
+    if ((AccelData_T.GyX.sample_int_s16 > ACCEL_TRIG_ROT) ||
+        (AccelData_T.GyX.sample_int_s16 < -(ACCEL_TRIG_ROT)))
+    {
+      AccelData_T.GyX.sample_int_s16 = 0; // Réinitialisation de l'intégrateur
+      accel_detect_x = true;
+    }
+    else
+    {
+      accel_detect_x = false;
+    }
+    
+    AccelData_T.GyX.sample2_s16=AccelData_T.GyX.sample1_s16; // Mémorisation de la mesure N-1
+
+    // Traitement de l'axe Y -----
+    // Filtre passe-bane pour GyY
+    AccelData_T.GyY.sample_filt_s16 = (AccelData_T.GyY.sample_filt_s16 + (AccelData_T.GyY.sample1_s16 - AccelData_T.GyY.sample2_s16)) >> 1;
+    
+    if ((AccelData_T.GyY.sample1_s16 > (ACCEL_THRES_ROT << 4)) ||
+        (AccelData_T.GyY.sample1_s16 < -(ACCEL_THRES_ROT << 4)) ||
+        (AccelData_T.GyY.sample_filt_s16 > ACCEL_THRES_ROT) || 
+        (AccelData_T.GyY.sample_filt_s16 < -(ACCEL_THRES_ROT))) // Détection du passage de seuil
+    {
+      AccelData_T.GyY.sample_int_s16 += (AccelData_T.GyY.sample1_s16 >> 9); // Integration
+    }
+
+    if ((AccelData_T.GyY.sample_int_s16 > ACCEL_TRIG_ROT) ||
+        (AccelData_T.GyY.sample_int_s16 < -(ACCEL_TRIG_ROT)))
+    {
+      AccelData_T.GyY.sample_int_s16 = 0; // Réinitialisation de l'intégrateur
+      accel_detect_y = true;
+    }
+    else
+    {
+      accel_detect_y = false;
+    }
+    
+    AccelData_T.GyY.sample2_s16=AccelData_T.GyY.sample1_s16; // Mémorisation de la mesure N-1
+    
+    // Traitement de l'axe Z -----
+    // Filtre passe-bane pour GyZ
+    AccelData_T.GyZ.sample_filt_s16 = (AccelData_T.GyZ.sample_filt_s16 + (AccelData_T.GyZ.sample1_s16 - AccelData_T.GyZ.sample2_s16)) >> 1;
+    
+    if ((AccelData_T.GyZ.sample1_s16 > (ACCEL_THRES_ROT << 4)) ||
+        (AccelData_T.GyZ.sample1_s16 < -(ACCEL_THRES_ROT << 4)) ||
+        (AccelData_T.GyZ.sample_filt_s16 > ACCEL_THRES_ROT) || 
+        (AccelData_T.GyZ.sample_filt_s16 < -(ACCEL_THRES_ROT))) // Détection du passage de seuil
+    {
+      AccelData_T.GyZ.sample_int_s16 += (AccelData_T.GyZ.sample1_s16 >> 9); // Integration
+    }
+
+    if ((AccelData_T.GyZ.sample_int_s16 > ACCEL_TRIG_ROT) ||
+        (AccelData_T.GyZ.sample_int_s16 < -(ACCEL_TRIG_ROT)))
+    {
+      AccelData_T.GyZ.sample_int_s16 = 0; // Réinitialisation de l'intégrateur
+      accel_detect_z = true;
+    }
+    else
+    {
+      accel_detect_z = false;
+    }
+    
+    AccelData_T.GyZ.sample2_s16=AccelData_T.GyZ.sample1_s16; // Mémorisation de la mesure N-1
+
+    // Concatenation  des trois axes
+    accel_detect = accel_detect_x || accel_detect_y ||accel_detect_z;
+
+  #else //ACCEL_ROTATION_DETECT
+    // Cas sans détection de rotation mais avec seul mesure de la force d'accélération
+    if ((AccelData_T.GyX.sample1_s16 > ACCEL_THRES_GYX) || 
+        (AccelData_T.GyY.sample1_s16 > ACCEL_THRES_GYY) || 
+        (AccelData_T.GyZ.sample1_s16 > ACCEL_THRES_GYZ) || 
+        (AccelData_T.GyX.sample1_s16 < ((int16_t)(-1) * ACCEL_THRES_GYX)) ||
+        (AccelData_T.GyY.sample1_s16 < ((int16_t)(-1) * ACCEL_THRES_GYY)) ||
+        (AccelData_T.GyZ.sample1_s16 < ((int16_t)(-1) * ACCEL_THRES_GYZ)))
+    {
+      accel_detect = true;
+    }
+    else
+    {
+      accel_detect = false;
+    }
+  #endif //ACCEL_ROTATION_DETECT
+
+  // Machine à état principale : on fait des trucs !
+  //-------------------
+  switch (stmState)
+  {
+  // Initialisation pas encore utiliée, prévu pour utilisation future
+    case STM_INIT:
+      stmState = STM_IDLE;
+    break;
+
+    case STM_IDLE:
+      //digitalWrite(LED_BUILTIN, LOW); // DEBUG
+      if ((accel_detect == true))
+      {
+        stmState = STM_PLAY;
+      }
+    break;
+
+    case STM_PLAY:
+      WritePlaySong(cPlaylistIndif_TA[song_playing_current_u8].song_index_u8 + 1U);            // Lecture de la piste actuellement selectionnée (exemple: index à 0 + 1 = piste 1)
+      //digitalWrite(LED_BUILTIN, HIGH); // DEBUG
+      play_blank_delay_threshold = cPlaylistIndif_TA[song_playing_current_u8].blank_delay_u16; // Chargement du temps d'attente pour le rejeux de la piste
+      song_cycles_cnt_u8++;                                                                    // Incrémentation du compteur de lecture de piste
+      
+      if (song_cycles_cnt_u8 >= cPlaylistIndif_TA[song_playing_current_u8].cycles_number_u8)
+      { // Vérification de si le compteur de lecture dépasse la valeur maximale définie plus haut
+        song_cycles_cnt_u8 = 0;       // Réinitialisation du compteur de lecture
+        song_playing_current_u8++;    // Passage à la piste audio suivante (index de piste = index courrant + 1)
+      }
+
+      if (song_playing_current_u8 >= PLAYLIST_LENGTH)
+      { // Vérification de si l'index de piste dépasse le nombre maximale de piste sur le module MP3
+        song_playing_current_u8 = 0;  // Réinitialisation de l'index de piste audio 
+      }
+      
+      play_blank_delay = millis();    // Enregistrement de la valeur courante d'attente pour la prochaine lecture
+      stmState = STM_BLANK;           // Passage à l'état STM_BLANK
+    break;
+
+    case STM_BLANK:
+      millis_temp = millis();         // Obtention du temps actuel en millisecondes
+
+      if ((millis_temp >= play_blank_delay) && ((millis_temp - play_blank_delay) > play_blank_delay_threshold))
+      { // Comparaison entre le temps actuelle et la valeur d'attente enregistrée
+        stmState = STM_IDLE;         // Passage à l'état STM_IDLE
+
+      }
+      else if (millis_temp < play_blank_delay)
+      { // Overflow protection for uptime of several weeks or more.
+        play_blank_delay = 0;
+      }
+    break;
+
+    case STM_MP3_RESET:
+      millis_temp = millis();
+      //digitalWrite(LED_BUILTIN, LOW); // DEBUG
+      if ((millis_temp >= mp3_reset_delay) && ((millis_temp - mp3_reset_delay) > DELAY_MP3_RESET))
+      {
+        stmState = STM_IDLE;
+        digitalWrite(PIN_GROUND_SWITCH, HIGH);
+      }
+      else if (millis_temp < mp3_reset_delay)
+      { // Overflow protection for uptime of several weeks or more.
+        mp3_reset_delay = 0;
+      }
+    break;
+
+    default:
+      stmState = STM_INIT;
+    break;
+  }
+}
+
+/*
+  SerialEvent est exécuté chaque fois qu'une nouvelle donnée arrive dans le RX série matériel. Cette routine
+  Cette routine est exécutée entre chaque exécution de loop(), donc l'utilisation d'un délai dans la boucle peut
+  retarder la réponse. Plusieurs octets de données peuvent être disponibles.
+*/
+void serialEvent() {
+  while (Serial.available()) {
+    // Obtention du nouvel octet:
+    char inChar = (char)Serial.read();
+    // ajout de l'octet  à la chaîne de caractère inputString:
+    inputString += inChar;
+    // Si le cacratère contenu dans l'octet est un retour à la ligne, définir marquer la ligne comme complète
+    if (inChar == '\n') {
+      stringComplete = true;
+    }
+  }
+}
+
+void ReadPlayState (void)
+{
+  // Commande pour obtenir l'état du module MP3 (voir doc PDF)
+  Serial.write(170); // 0xAA
+  Serial.write(1);   // 0x01
+  Serial.write(0);   // 0x00
+  Serial.write(171); // 0xAB
+}
+
+void WritePlay (void)
+{
+  // Commande pour demander  jouer une piste 
+  Serial.write(170); // 0xAA
+  Serial.write(2);   // 0x02
+  Serial.write(0);   // 0x00
+  Serial.write(172); // 0xAC
+}
+
+void WritePlaySong (uint16_t index)
+{
+  // Commande pour demander la lecture d'une piste spécifique
+  uint8_t buffer_u8A[5];
+  buffer_u8A[0] = 0xAA;
+  buffer_u8A[1] = 0x07;
+  buffer_u8A[2] = 0x02;
+  buffer_u8A[3] = (uint8_t)((index >> 8U) & (uint16_t)0x00FF);
+  buffer_u8A[4] = (uint8_t)(index & (uint16_t)0x00FF);
+  uint8_t crc_u8 = CrcCalculate(buffer_u8A, 5);
+  // Commande à proprement parler
+  Serial.write((int)buffer_u8A[0]); // 0xAA
+  Serial.write((int)buffer_u8A[1]); // 0x07
+  Serial.write((int)buffer_u8A[2]); // 0x02
+  Serial.write((int)buffer_u8A[3]); // Song number high byte
+  Serial.write((int)buffer_u8A[4]); // Song number low byte
+  Serial.write((int)crc_u8);        // CRC
+}
+
+uint8_t CrcCalculate (uint8_t *buff, uint8_t size)
+{
+  // Calcule du code correcteur d'erreur
+  uint16_t ret_u16 = 0;
+  uint8_t cnt_u8 = 0;
+
+  for (cnt_u8 = 0; cnt_u8 < size; cnt_u8++)
+  {
+    ret_u16 += *(buff + cnt_u8);
+  }
+
+  return ((uint8_t)(ret_u16 & (uint16_t)0x00FF));
+}
\ No newline at end of file