Chronometre a decompte port serie

// --------------------------------------------
// Chronomètre à rebourd avec saisie
// --------------------------------------------
// Chronomètre à affichage digital sur
// afficheur 4 digits rouges OCTOPUS EF04056
// https://www.elecfreaks.com/learn-en/microbitOctopus/sensor/octopus_ef04056.html
// avec buzzer pour compte à reboud, feu et fin
// Module buzzer Gravity DFR0032
// https://wiki.dfrobot.com/Digital_Buzzer_Module__SKU__DFR0032_
// possibilité de saisie de nouveau temps par
// le port série.
// --------------------------------------------

// --------------------------------------------
// Instructions de montage --------------------
// --------------------------------------------
// Afficheur 7 digits 4 segments D8 (CLK),
// D3 (DIO), 5V et Gr.
// Buzzer en D4 3.3V et Gr.
// --------------------------------------------

// --------------------------------------------
// Fonctionnement -----------------------------
// --------------------------------------------
// le chronomètre fait un comte à rebourd de 5s
// avant de se lancer accompagné de 4 bip + un
// bip différent pour "FEU"
// Le chronomètre fait un troisième bip quand
// le compte à rebourd est à 0.
// Le temps par défaut est de 15 secondes.
// pour faire un compte à rebourd de 15 s,
// appuyer sur le bouton reset de l'Arduino
// (ou compatible).
// Pour changer le tenps par défaut changer
// la valeur de la variable temps.
// --------------------------------------------


#include <TM1637Display.h>                      // on va chercher la bibliothèque

// DIGIT 7 Segments                             // composition d'un afficheur digital

//    ┌--A--┐
//    F      B
//    ├--G--┤
//    E      C
//    └--D--┘

// ---------------

#define CLK 8                                   // on définit le pin de connexion sur lequel est CLK
#define DIO 3                                   // on définit le pin de connexion sur lequel est DIO

TM1637Display display(CLK, DIO);                // on initialise l'afficheur

uint8_t data[] = { 0xff, 0xff, 0xff, 0xff };    // on déclare le tableau des valeurs à afficher

int k;                                          // variable qui servira pour les boucles
unsigned long raz;                              // variable qui sera le tempon pour le chrono
int temps = 15;                                 // temps par défaut du chronomètre
bool chronoTourne;                              // variable qui dit si le chrono tpurne ou pas
char valeurSerial;                              // variable contenant la donnée reçue du port série
bool receptionSerial = false;                   // variable qui dit si on reçoit des données du port série ou non
String recu = "";                               // variable contenant la chaine des caractères reçus par le port série
const int buzzer = 4;                           // variable qui contien le port sur lequel est le buzzer
const int duree = 200;                          // variable qui contient la fréquence du buzzer pour le compte à rebourd
const int duree2 = 189;                         // variable qui contient la fréquence du buzzer pour la fin
const int duree3 = 250;                         // variable qui contient la fréquence du buzzer pour le feu
int buzz = 0;                                   // variable qui dit si le feu a été donné ou non
int cRebourd = 1;                               // variable qui dit si le compte à rebourd à été fait ou non
int longueurCompt = 0;                          // variable qui va permettre d'afficher l'avancée du chrono sur le moniteur série
unsigned long ajoutTot;

// --------------------------------------------------------------------------------
// SETUP () -----------------------------------------------------------------------
// --------------------------------------------------------------------------------

void setup() {                                  // SET UP *************************************

  Serial.begin(9600);                           // on initialise la communication avec le PC par le port série
  pinMode(buzzer, OUTPUT);                      // définition du buzzer en sortie

  /* la suite c'est juste pour faire style, pour animer le moniteur série */

  MS_barreHoriz ();                             // Mise en page moniteur série
  MS_centreTexteCadre ("Initialisation en cours"); // on affiche le message

  MS_fauxChargement ();                         // fausse pogression de l'initialisation

  MS_centreTexteCadre ("Initialisation  OK !"); // on affiche le message
  MS_barreHoriz ();                             // Mise en page moniteur série

  delay (250);                                  // pause de 0.25 s

  MS_nouveauTemps ("        Temps : ");         // on affiche le temps sur le moniteur série

  initialisation ();                            // on lance la fonction initailisation ()
  raz = millis ();                              // on réinitialise le seuil du temps (tampon)

}

// --------------------------------------------------------------------------------
// LOOP () ------------------------------------------------------------------------
// --------------------------------------------------------------------------------

void loop(){                                    // LOOP ***************************************



  chronometre ();                               // on lance la fonction chronomètre



}

// --------------------------------------------------------------------------------
// Fonctions ----------------------------------------------------------------------
// --------------------------------------------------------------------------------

// --------------------------------------------
// Fausse initialisation / compte à rebourd ---
// --------------------------------------------

void initialisation () {

  display.clear();                                // on efface les donnée à afficher
  delay(10);                                      // pause de 10 ms

  for ( k = 0 ; k < 4 ; k++ ) {                   // on tourne de façon croissante sur le 4 niveaux de luminosité

    display.setBrightness(k);                     // on note la valeur de l'intensité de la luminosité des digits

    display.showNumberDec( 4 - k, false, 1, 3 - k); // on affiche la valeur 3-k sur le digit 4-k

    bipBuzzer (250, duree);                       // on fait sonner le BIP de compte à rebours

    delay(1000);                                  // pause 1 s

    display.clear();                              // on efface les donnée à afficher

  }

  bipBuzzer (500, duree3);                        // on fait sonner le BIP de feu

  MS_barreHoriz ();                               // Mise en page moniteur série
  MS_centreTexteCadre ("Décompte en cours...");   // on affiche le message
  MS_barreHoriz ();                               // Mise en page moniteur série
}

// --------------------------------------------
// Fonction du chronomètre --------------------
// --------------------------------------------

void chronometre () {

// --------------------------------------------
// Si le chrono TOURNE ------------------------

// --------------------------------------------
// Si le chrono FINIT -------------------------

  if ( ( millis() - raz ) > ( temps * 1000UL ) ) {  // si le temps écoulé du chrono est > que le temps (max) * 1000UL (UL pour le forcer à calculer en uint32_t, sinon, il calcule en uint13_t par défaut)

    cRebourd = 0;                                 // on dit que le compte à rebourd n'est pas fait

    display.showNumberDecEx( temps * 100, 0b01000000, false, 4 , 0 ); // on affiche la valeur du temps fini

    if ( buzz == 0 ) {                            // si le buzz feu n'a pas sonné

      bipBuzzer (1000, duree2);                   // on fait le BIP de fin

      buzz = 1;                                   // on dit que le buzz feu a sonné
      chronoTourne = false;                       // on dit que le chronmètre ne tourne plus
      longueurCompt = 0;                          // on remet à zéro le compteur de progression

      Serial.println ();                          // retour à la ligne
      MS_barreHoriz ();                           // Mise en page moniteur série
      MS_centreTexteCadre ("Décompte terminé !"); // on affiche le message
      MS_barreHoriz ();                           // Mise en page moniteur série
    }

// --------------------------------------------
// Si le chrono n'est PAS FINI ----------------

  } else {                                        // si le temps écoulé du chrono est < que le temps (max) * 1000
    if ( cRebourd == 0 ) {                        // si le compte à rebourd n'a pas été fait

      initialisation ();                          // on lance la fonction initialisation (compte à rebourd)
      raz = millis ();                            // on réinitialise le seuil du temps (tampon)
      cRebourd = 1;                               // on dit que le compte à rebourd a été fait

    }

    display.showNumberDecEx(( millis() - raz ) / 10, 0b01000000, false, 4 , 0); // on affiche le temps écoulé

// Rajout d'une "boucle" pour afficher la progression sur le moniteur série

  ajoutTot = ( ( millis () - raz) * 28 ) / (temps * 1000UL); // on calcule le nombre de barre qui doivent être affichées (UL pour le forcer à calculer en uint32_t, sinon, il calcule en uint16_t par défaut)

  for ( int i = 0 ; i < ( ajoutTot - longueurCompt ) ; i++){  // tourne tant qu'il n'a pas ajouté tout ce qui manque

    Serial.write ( "|" );                         // affiche "|" sur le moniteur série
    longueurCompt += 1 ;                          // on incrémente la longueur affichée de 1

  }

    chronoTourne = true;                          // on dit que le chrono tourne encore
    recu = "";                                    // on réinitialise les valeurs reçues

  }

// ------------------------------------------------------
// Si le chrono NE TOURNE PAS ---------------------------

  if ( chronoTourne == false ) {                  // si le chrono ne tourne pas

// --------------------------------------------
// Si on RECOIT du port série -----------------

    if ( Serial.available() ) {                   // si on reçoit des données du port série

      valeurSerial = Serial.read();               // la variable valeurSerial prend la valeur de ce qui est reçu

      if ( valeurSerial > 47 && valeurSerial < 59 ){ // si la valeur reçue est un chiffre entre 0 et 9
                                                  // valeurs en Decimal https://upload.wikimedia.org/wikipedia/commons/d/dd/ASCII-Table.svg
        Serial.println ();                        // retour à la ligne
        MS_barreHoriz ();                         // Mise en page moniteur série
        Serial.write ("| - Réception port série - |");  // on affiche le message sur le moniteur série
        Serial.println ();                        // retour à la ligne
        MS_barreHoriz ();                         // Mise en page moniteur série
        MS_valeursRecues ();                      // on affiche le message sur le moniteur série
        MS_barreHoriz ();                         // Mise en page moniteur série
        MS_centreTexteCadre ("****");             // on affiche le message sur le moniteur série
        Serial.println ();                        // retour à la ligne

      }

      if ( receptionSerial == false ) {           // Si on ne recevait rien du port série avant, ...

        receptionSerial = true;                   // on dit qu'on reçoit des valeurs du port série

      }

      recu += valeurSerial;                       // on ajoute la valeur reçue à la chaine de caractère recu

// --------------------------------------------
// Si on NE RECOIT PAS du port série ----------

    } else {                                      // si on ne reçoit rien

      if (receptionSerial == true) {              // si on recevait des données du port série avant, ...

        receptionSerial = false;                  // on dit qu'on en reçoit plus
        raz = millis ();                          // on réinitialise le seuil du temps (tampon)
        temps = ( recu.toInt() );                 // on transforme la chaine de caractères reçue en valeur numérique entière
        buzz = 0;                                 // on dit que le buzzer n'a pas sonné

        MS_nouveauTemps ("    Nouveau temps : "); // on affiche le nouveau temps a chronométrer sur le moniteur série

      }
    }
  }
}

// --------------------------------------------
// Fonctions activation Buzzer ----------------
// --------------------------------------------

void bipBuzzer (int longu, int freq){

  for (int i = 0; i < longu; i++) {                 // début du bip fin du buzzer

    digitalWrite( buzzer, HIGH );                   // on allume le buzzer...
    delayMicroseconds( freq );                      // pendant 189 ms

    digitalWrite( buzzer, LOW );                    // on éteind le buzzer...
    delayMicroseconds( freq );                      // pendant 189 ms

  }
}

// --------------------------------------------------------------------------------
// Fonctions Moniteur Série -------------------------------------------------------
// --------------------------------------------------------------------------------

// --------------------------------------------
// Fonction chargement ------------------------
// --------------------------------------------
void MS_fauxChargement (){

  for (int i = 0 ; i <= 27 ; i++) {               // fausse pogression de l'initialisation

    Serial.write ("|");                           // affiche des "|"
    delay (1000 / 28);                            // 28 "|" en 1 seconde

  }
  Serial.println ();                              // retour à la ligne
}

// --------------------------------------------
// Fonction barre horizontale -----------------
// ( Mise en page du moniteur série ) ---------
// --------------------------------------------

void MS_barreHoriz (){

  Serial.write ("| ------------------------ |");  // mise en page du message affiché sur le moniteur série
  Serial.println ();                              // retour à la ligne

}

// --------------------------------------------
// centrage de texte dans un cadre ------------
// ( Mise en page du moniteur série ) ---------
// --------------------------------------------

void MS_centreTexteCadre (String texte){

  for (int i = 0 ; i <  int(( 28 - texte.length() )/ 2 ) ; i ++){
    Serial.write ( " " );
  }

  Serial.println (texte);

}

// --------------------------------------------
// affichage Nouveau temps --------------------
// ( Mise en page du moniteur série ) ---------
// --------------------------------------------

void MS_nouveauTemps (String texte){

  Serial.println ();                        // retour à la ligne
  Serial.print (texte);                     // on affiche "Nouveau temps : " sur le moniteur série
  Serial.print (temps);                     // on affiche la valeur du nouveau temps sur le port série
  Serial.write (" s");                      // on affiche " s" sur le moniteur série
  Serial.println ();                        // retour à la ligne
  Serial.println ();                        // retour à la ligne

}

// --------------------------------------------
// affichage Valeurs reçues -------------------
// ( Mise en page du moniteur série ) ---------
// --------------------------------------------

void MS_valeursRecues (){

        Serial.write ("      Valeur reçue : ");   // on ecrit "Valeur reçue : " sur le moniteur série
        Serial.println ( valeurSerial );          // on écrit la valeur de la variable valeurSerial

}

// --------------------------------------------
// Suite du projet ----------------------------
// --------------------------------------------
// Mettre des sécurités / vérifications au cas
// ou les valeurs entrées ne soient pas des
// chiffres.
// --------------------------------------------
// Rajouter un clavier ou en faire un avec des
// boutons poussoirs et remplacer la saisie en
// port série par la saisie sur le clavier.
// C'est peut être même + simple à programmer.
// --------------------------------------------
// Dynamiser un peu plus le projet pour pouvoir
// fait des comptes à rebourd de + de 99.99s.
// Pour ça, il faut déplacer le point de façon
// dynamique. Il faudra faire une fonction
// avec des arguments et des tests de longueur
// de la valeur "temps", avant.
// --------------------------------------------