programmateur de 89S52/at89lp51 etc atmel LP

j ai réalisé il y a déja quelques temps un programmateur de atmel at89lpxxxx  pas cher  sur interface usb  .
j ai écrit le soft PC   avec  delphi
comme dans tous programmateur  on a besoin de tempo  assez précise  .
j ai utilisé  Sleep(xmS)   mais je constate que par exemple si je mets une tempo  de Sleep(50)  j ai entre 10 et 30ms (ça change meme en boucle) mais si
je mets  Sleep(100) je n ai pas le double mais parfois beaucoup moins  ???
est ce que quelqu un est féru de delphi ou lazarus  et pourrais m éclairer  sur les tempos ?

Bonjour,
J'ai posé la question au CHAT :

j'ai écrit un programmateur de atmel at89lpxxxx  sur interface usb  en langage Delphi. Si je mets une tempo  de Sleep(50)  j'ai entre 10 et 30ms et si je mets  Sleep(100) je n ai pas le double mais parfois beaucoup moins . Pourquoi?

Il y a plusieurs raisons pour lesquelles la fonction Sleep() peut ne pas donner le temps de pause exact que vous spécifiez :

La résolution de temps de la fonction Sleep() est limitée. Sur Windows, la résolution est généralement de 15,6 ms ou 10 ms, selon la version de Windows que vous utilisez. Cela signifie que si vous spécifiez une pause de 50 ms, vous pourriez obtenir un temps de pause compris entre 46,8 ms et 62,5 ms, en fonction de la résolution de temps.

D'autres processus en cours d'exécution sur votre ordinateur peuvent affecter la précision de la fonction Sleep(). Si votre ordinateur est occupé à effectuer d'autres tâches pendant que votre programme est en cours d'exécution, cela peut entraîner des variations dans le temps de pause.

Le temps de pause peut également être affecté par la façon dont vous utilisez la fonction Sleep() dans votre programme. Si vous utilisez la fonction Sleep() dans une boucle, par exemple, cela peut entraîner des temps de pause variables en fonction du nombre de fois que la boucle est exécutée.

Dans votre cas, il est possible que les variations de temps de pause que vous constatez soient dues à l'une ou plusieurs de ces raisons. Si vous avez besoin d'une pause précise, vous pourriez envisager d'utiliser une minuterie ou un autre mécanisme de synchronisation qui offre une résolution de temps plus précise.

Sous Linux, vous pouvez utiliser la bibliothèque GTK+ pour créer des interfaces graphiques en Delphi. La bibliothèque GTK+ offre des fonctionnalités pour les interfaces graphiques, ainsi que pour les entrées/sorties avec le système d'exploitation.

Pour créer des délais précis en Delphi sous Linux, vous pouvez utiliser la fonction usleep() de la bibliothèque standard C. Cette fonction accepte un argument en microsecondes et suspend l'exécution du programme pendant le nombre de microsecondes spécifié. Vous pouvez l'utiliser pour créer des délais précis et prévisibles.

Voici un exemple de code en Delphi pour utiliser la fonction usleep() :

Code:

{$IFDEF LINUX}
  uses baseunix;
{$ENDIF}

...

{$IFDEF LINUX}
  // Suspend l'exécution du programme pendant 50 millisecondes
  usleep(50000);
{$ELSE}
  // Code pour Windows
  Sleep(50);
{$ENDIF}

Notez que la directive de compilation {$IFDEF LINUX} permet de compiler le code spécifiquement pour Linux. Si vous souhaitez exécuter le même code sur Windows et sur Linux, vous pouvez utiliser la fonction sleep() de Delphi, mais gardez à l'esprit que la résolution de temps peut varier entre les systèmes d'exploitation.

J'ai continué ma discussion avec ChatGPT:

quelle est l'alternative à sleep()

L'alternative à la fonction sleep() est d'utiliser une minuterie ou un mécanisme de synchronisation pour créer des délais précis. Voici quelques exemples :

Utilisation de la classe TTimer en Delphi/Lazarus : La classe TTimer permet de créer une minuterie qui envoie périodiquement un événement à l'application. Vous pouvez utiliser cette minuterie pour créer des délais précis en définissant la propriété Interval sur la durée souhaitée en millisecondes.

Utilisation de la fonction GetTickCount en Delphi/Lazarus : La fonction GetTickCount renvoie le nombre de millisecondes écoulées depuis le démarrage de l'ordinateur. Vous pouvez utiliser cette fonction pour mesurer le temps écoulé et créer des délais précis en comparant les valeurs retournées par GetTickCount.

Utilisation de la fonction nanosleep() en C/C++ : La fonction nanosleep() est une fonction système qui suspend l'exécution du programme pendant une durée spécifiée en nanosecondes. Cette fonction offre une résolution de temps très précise et peut être utilisée pour créer des délais précis en C/C++.

Utilisation de la fonction select() en C/C++ : La fonction select() est une fonction système qui permet d'attendre sur plusieurs descripteurs de fichiers en même temps. Cette fonction peut être utilisée pour créer des délais précis en spécifiant une liste de descripteurs de fichiers vides et en utilisant la valeur de retour pour déterminer la durée d'attente.

Ces alternatives offrent une précision de temps plus élevée que la fonction sleep(), mais elles peuvent être plus complexes à utiliser et nécessitent souvent des connaissances avancées en programmation système.

Je me pencherais sur l'API QueryPerformanceCounter qui est sensée avoir une précision meilleure que 1µs.
Il est notoire que les fonctions basées sur l'API Sleep donnent du n'importe quoi...

merci pour ces infos !
pour l instant je m en tire par une pirouette :
j ai un parametre à l ecran que je peux incrementer  et qui me permet d augmenter les timings jusqu a ne plus avoir d erreur .

j ai utilisé GetTickCount pour mesurer la durée des sleep
en dessous de 50   la vraie valeur varie entre   24  et 40
au dessus  de 50 la vraie valeur  varie entre 50 et 66
donc effectivement  Sleep n est vraiment pas precis
je vais inclure GetTickCount à la place des Sleep !