Discussion :

[boboss123]

Bonjour,

J'ai une variable de type non signé codée sur 32 bits (correspond à un unsigned int)

Cette variable sert de timer (elle représente une valeur en 1/1000000 seconde).
J'ai la fonction getTimer() qui me donne le temps écoulé depuis l'allumage du système.

donc si à un instant t, getTimer() me donne comme résultat 0xFFFFFFFF => 1/1000000 seconde plus tard, il me donnera comme résultat 0 (car overflow de la variable).


J'ai plein de timer à gérer : sur certains événement je crée des timeouts qui doivent déclencher des actions lorsqu'ils sont écoulés :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
// x et y toujours inférieurs à 0xFFFFFFFF / 8
timeout1 = getTimer() + x;
...
...
...
timeout2 = getTimer() + y;
...
...

Ce que je veux, c'est effectuer une action dès que l'un des timeout est déclenché (c'est à dire que timeoutx < getTimer()) : le problème est que je ne vois comment traiter l'overflow.

Par exemple si getTimer() = 0xFFFFFFFA et que timeout = getTimer() + 0xFF, le test "timeoutx < getTimer()" n'est plus valide pour détecter le déclenchement du timeout car timeout vaudra 0xFFFFFFFA + 0xFF = 0x100000F9 ce qui correspond a 0x00000F9 sur une variable 32 bits.

Il faut que le traitement soit rapide car je programme sur un µControlleur 32 bits.

Est-ce que vous voyez une solution ?

Merci d'avance,

[Obsidian]

Il faut que le traitement soit rapide car je programme sur un µControlleur 32 bits. Est-ce que vous voyez une solution ? Merci d'avance,

« unsigned long long int ». C'est le moyen le plus efficace de disposer d'au moins 64 bits sans se faire suer, ce qui te permettrait de définir des timeout sur plusieurs centaines d'années.

Sinon, tu fais une structure à deux champs comme il en existe beaucoup sur les différents systèmes d'exploitation (comme struct timeval), du style :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
struct timestamp
{
      signed long int secondes;
    unsigned long int microsecondes;
}

Ceci te permettra d'écrire des fonctions pouvant recevoir de telles structures en argument et en renvoyer.

Ensuite, si toutes tes fonctions reposent sur l'examen d'un compteur incrémenté par une source externe, le plus simple est de conserver une copie de ce compteur à chaque fois que tu relèves sa valeur, associé à un second compteur qui n'est mis à jour que par toi. Dès lors que la valeur relevée devient inférieure à sa copie, c'est qu'il y a eu dépassement. Il te suffit alors d'incrémenter ton compteur et de revenir à l'état normal.

[boboss123]

ok merci, cette solution a l'air la plus efficace