Chrono

Doc et Lib rédigée par Swifter

clicez ici

Chrono.h est une librairie simple d’utilisation, qui permet :

• De chronométrer une durée avec une precision au centième de seconde.
• De mettre en place un decompte de temps.
• De mettre en pause une mesure de temps.
• De faciliter l’affichage de la durée mesurée.

Le type TIME est un tableau contenant les 3 valeurs numériques de la durée mesurée.

//Creation d'une variable de type TIME :
TIME une_duree = { 95,12,2 };     

• une_duree[0] : les centiemes de secondes (ici 95)
• une_duree[1] : les secondes (ici 12)
• une_duree[2] : les minutes (ici 2)

Le type CHRONO est la structure principale et obligatoire pour utiliser la librairie. Les composants de la structure :

typedef struct
{   TIME time;
    TIME decount;
    unsigned char chrono_str[9];
    FORMAT format;
} CHRONO;
//Creation d'une structure de type CHRONO :
CHRONO un_chronometre;       

• un_chronometre.time : Contient la durée mesurée par le chronometre
• un_chronometre.decount : Contient un decompte de temps (s’il a été définit auparavant).
• un_chronometre.chrono_str : Contient la chaine de caractère correspondante à la durée mesurée par le chronomètre ou le decompte de temps.
• un_chronometre.format : Format sous lequel est créée la chaine “chrono_str” (voir en dessous).

Il peut être changé à n’importe quel moment.

Le type FORMAT est une enumération des paramètres suivants : NOT, AUTO, ALL, MIN et CENT. Il permet de définir comment va être créée la chaine “chrono_str” d’une structure CHRONO.

• ALL : Créé la chaine avec les minutes, les secondes et les centièmes
• MIN : Créé la chaine avec les minutes et les secondes
• CENT : Créé la chaine avec les secondes et les centièmes
• AUTO : Créé la chaine avec les minutes, si elles ne sont pas nulles, avec les secondes et les centièmes
• NOT : Ne créé pas la chaine “chrono_str”

Exemple 1 : “un_chronometre.time” contient la durée 15 minutes 8 secondes et 12 centièmes :

  un_chronometre.format == ALL    =>   un_chronometre.chrono_str == "15:08:12"
  un_chronometre.format == MIN    =>   un_chronometre.chrono_str == "15:08"
  un_chronometre.format == CENT   =>   un_chronometre.chrono_str == "8:12"
  un_chronometre.format == AUTO   =>   un_chronometre.chrono_str == "15:08:12"

Exemple 2 : “un_chronometre.time” contient la durée 0 minutes 42 secondes et 9 centièmes :

  un_chronometre.format == ALL    =>   un_chronometre.chrono_str == "0:42:09"
  un_chronometre.format == MIN    =>   un_chronometre.chrono_str == "0:42"
  un_chronometre.format == CENT   =>   un_chronometre.chrono_str == "42:09"
  un_chronometre.format == AUTO   =>   un_chronometre.chrono_str == "42:09"

Initialise et démarre le chronomètre “chr”.

“str_frm” est le format sous lequel la chaîne “chr→chrono_str” va être créée (et actualisée).

Actualise toutes les valeurs du chronomètre “chr” (à savoir “chr→time” et “chr→chrono_str”).

Initialise et démarre le décompte de temps “dec”.

Le temps de départ est définit par les variables “min” (minutes), “sec” (secondes) et “cent” (centièmes de seconde).

“str_frm” est le format sous lequel la chaîne “dec→chrono_str” va être créée (et actualisée).

Actualise toutes les valeurs du décompte de temps “dec” (à savoir “chr→decount” et “chr→chrono_str”).

La fonction renvoie 1 lorsque le décompte de temps est terminé, sinon elle renvoie 0.

Met en pause un chronomètre ou un décompte de temps “chr”.

La fonction renvoie 1 si une pause a déjà été mise sur ce chronomètre, sinon, si tout c’est bien passé, elle retourne 0.

Enlève la pause qui a été mise sur un chronomètre ou un décompte de temps “chr”.

La fonction renvoie 1 si aucune pause n’avait été mise sur ce chronomètre, sinon, si tout c’est bien passé, elle retourne 0.

Place le temps contenu dans un chronomètre (ou un décompte de temps) dans une variable de type TIME.

Cette fonction peut être utile lorsqu’il faut sauvegarder des temps.

Convertit le temps contenu dans une variable de type TIME, en chaîne de caractères, selon le format “str_frm” voulu.

Retourne 1 a chaque changement de secondes, sinon retourne 0.

Le parametre “init” doit valoir 1 a la premiere utilisation de la fonction. Ensuite, il doit valoir 0.

Exemple :

for (i=2;i<1000;i++) variable = new_sec(i==2);

Retourne 1 tous les 2 centièmes de secondes, sinon retourne 0.

Renvoit les frames par seconde d’une boucle (la vitesse d’une boucle).

#include "db-lib.h"
#include "chrono.h"
void main()
{
  CHRONO un_temps;             // Création d'une structure de type CHRONO.
  mode(0xdb);
  contrast(15);
  desactint9();
  clear3(SEG1);
  init_decount(&un_temps,3,0,0,ALL);// On créé un décompte de temps de 3 min.
  do        // Tant que le décompte n'est pas fini : 
   { locate(4,4,un_temps.chrono_str,SEG1);// On affiche le temps qu'il reste,
   } while (!act_decount(&un_temps));  // et on actualise la structure CHRONO.
  mode(0xc3);
  contrast(8);
  actint9();
}

#define NB_LOOP  5000
#include "chrono.h"
#include "db-lib.h"
#include <stdio.h>
void main()
 {
  CHRONO un_temps;   // Creation d'une structure de type CHRONO.
  unsigned int i;
  float moyenne;
  desactint9();
  clear(SEG1);
  init_chrono(&un_temps,ALL);   // On lance le chronomètre.
  for (i=0;i<NB_LOOP;i++) invscreen(SEG1);//On exécute 5000 fois une foncx quelconque.
  act_chrono(&un_temps);   // On récupère le temps écoulé depuis init_chrono().
           // On le convertit en centièmes de secondes, puis on fait la moyenne :
           // Moyenne = (centièmes + 100*secondes + 6000*minutes) / 5000
  moyenne  = un_temps.time[0] + 100*un_temps.time[1] + 6000*un_temps.time[2];
  moyenne /= (float) NB_LOOP;
  printf("Temps : %sn",un_temps.chrono_str);
  printf("(Pour %d appels)nn",NB_LOOP);
  printf("La fonction dure:n%gncentiemes de sec",moyenne);
  waitkey(0x7F,0x7FF);
  emptykey();
  actint9();
}