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));
}