From fe7f3c14a8282c4ee349bf041f695482487024b2 Mon Sep 17 00:00:00 2001 From: lucasgrelaud Date: Sun, 25 Jun 2023 23:23:09 +0200 Subject: [PATCH] =?UTF-8?q?Ajout=20de=20deux=20sc=C3=A9narios=20bas=C3=A9e?= =?UTF-8?q?s=20sur=20le=20code=20initial=20de=20flax?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- sw/boitarire_sw/boitarire_sw.ino | 4 +- sw/scenarios/README.md | 60 +++ sw/scenarios/images/accelerometre.jpg | Bin 0 -> 21086 bytes sw/scenarios/images/capteur_inclinaison.jpg | Bin 0 -> 13959 bytes .../scenario1_capteur_inclinaison.ino | 366 ++++++++++++++ .../scenario2_accelerometre.ino | 446 ++++++++++++++++++ 6 files changed, 874 insertions(+), 2 deletions(-) create mode 100644 sw/scenarios/README.md create mode 100644 sw/scenarios/images/accelerometre.jpg create mode 100644 sw/scenarios/images/capteur_inclinaison.jpg create mode 100644 sw/scenarios/scenario1_capteur_inclinaison/scenario1_capteur_inclinaison.ino create mode 100644 sw/scenarios/scenario2_accelerometre/scenario2_accelerometre.ino diff --git a/sw/boitarire_sw/boitarire_sw.ino b/sw/boitarire_sw/boitarire_sw.ino index e0d4762..e1a9edd 100644 --- a/sw/boitarire_sw/boitarire_sw.ino +++ b/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 diff --git a/sw/scenarios/README.md b/sw/scenarios/README.md new file mode 100644 index 0000000..57704e2 --- /dev/null +++ b/sw/scenarios/README.md @@ -0,0 +1,60 @@ +# 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 diff --git a/sw/scenarios/images/accelerometre.jpg b/sw/scenarios/images/accelerometre.jpg new file mode 100644 index 0000000000000000000000000000000000000000..553691c7a832e5fe1fd7be520d4bc7b1634c9a37 GIT binary patch literal 21086 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 VtDF^bSAK)&=>Gd(-_O{8|JnKlziI#g literal 0 HcmV?d00001 diff --git a/sw/scenarios/images/capteur_inclinaison.jpg b/sw/scenarios/images/capteur_inclinaison.jpg new file mode 100644 index 0000000000000000000000000000000000000000..7e5ce0a9de48e176ccea7f279824da3731891ccc GIT binary patch literal 13959 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 literal 0 HcmV?d00001 diff --git a/sw/scenarios/scenario1_capteur_inclinaison/scenario1_capteur_inclinaison.ino b/sw/scenarios/scenario1_capteur_inclinaison/scenario1_capteur_inclinaison.ino new file mode 100644 index 0000000..5d487a3 --- /dev/null +++ b/sw/scenarios/scenario1_capteur_inclinaison/scenario1_capteur_inclinaison.ino @@ -0,0 +1,366 @@ +/* + 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)); +} + diff --git a/sw/scenarios/scenario2_accelerometre/scenario2_accelerometre.ino b/sw/scenarios/scenario2_accelerometre/scenario2_accelerometre.ino new file mode 100644 index 0000000..64568d7 --- /dev/null +++ b/sw/scenarios/scenario2_accelerometre/scenario2_accelerometre.ino @@ -0,0 +1,446 @@ +/* + 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 + + +// 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 -- GitLab