Chrono

Doc et Lib rédigée par Swifter

Télechargement

Pourquoi cette lib

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.

Les structures et les types de la librairie

Le type TIME

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

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

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"

Les fonctions de la librairie

void init_chrono(CHRONO* chr , FORMAT str_frm);

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).

void act_chrono(CHRONO* chr);

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

void init_decount(CHRONO* dec , int min, int sec, int cent, FORMAT str_frm);

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).

unsigned char act_decount(CHRONO* dec);

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.

unsigned char pause(CHRONO* chr);

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.

unsigned char end_pause(CHRONO* chr);

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.

void set_time(CHRONO chr, TIME* time);

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.

void time2str(TIME time, unsigned char far* adr_str, FORMAT str_frm);

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

unsigned char new_sec(unsigned char init);

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

unsigned char new_2cent( );

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

unsigned int act_fps( );

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

Exemples de codes

Utiliser un décompte de temps

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

Définir la vitesse d'une fonction quelconque

#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();
}
 
lib_temps.txt · Dernière modification: 2007/12/17 12:05 par 193.249.190.29
 
Recent changes RSS feed Creative Commons License Donate Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki